orizu 0.5.19 → 0.5.21

package/vendor/gepa-python/src/gepa/strategies/acceptance.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2025 Lakshya A Agrawal and the GEPA contributors
+# https://github.com/gepa-ai/gepa
+
+from typing import Protocol, runtime_checkable
+
+from gepa.core.state import GEPAState
+from gepa.proposer.base import CandidateProposal
+
+
+@runtime_checkable
+class AcceptanceCriterion(Protocol):
+    """Decides whether a proposed candidate should be accepted based on subsample evaluation results.
+
+    The ``should_accept`` method receives:
+
+    - ``proposal``: the full ``CandidateProposal`` containing:
+
+      - ``eval_before`` / ``eval_after``: ``SubsampleEvaluation`` objects with
+        per-example ``scores``, ``outputs``, ``objective_scores``, and ``trajectories``.
+      - ``subsample_scores_before`` / ``subsample_scores_after``: shorthand score lists.
+      - ``candidate``: the proposed candidate text.
+      - ``parent_program_ids``: indices of parent candidates.
+      - ``metadata``: free-form dict with LM prompts and raw outputs.
+
+    Implementations may additionally define an optional
+    ``reject_reason(proposal, state) -> str`` method; when present, the engine
+    uses it to produce an informative log message for rejected proposals
+    instead of the generic fallback.
+
+    - ``state``: the full ``GEPAState``, giving access to all existing candidates,
+      validation scores, the Pareto frontier, iteration count, etc.
+    """
+
+    def should_accept(self, proposal: CandidateProposal, state: GEPAState) -> bool:
+        """Return ``True`` if the proposed candidate should be accepted.
+
+        Args:
+            proposal: The full proposal including evaluation data, candidate, and metadata.
+            state: The current optimization state.
+        """
+        ...
+
+
+class StrictImprovementAcceptance:
+    """Accept only if the sum of new subsample scores is strictly greater than the old sum.
+
+    This is the default acceptance criterion used by GEPA.
+    """
+
+    def should_accept(self, proposal: CandidateProposal, state: GEPAState) -> bool:
+        old_sum = sum(proposal.subsample_scores_before or [])
+        new_sum = sum(proposal.subsample_scores_after or [])
+        return new_sum > old_sum
+
+
+class ImprovementOrEqualAcceptance:
+    """Accept if the sum of new subsample scores is greater than or equal to the old sum.
+
+    Useful when you want to allow lateral moves that don't improve the score but
+    may explore different regions of the solution space.
+    """
+
+    def should_accept(self, proposal: CandidateProposal, state: GEPAState) -> bool:
+        old_sum = sum(proposal.subsample_scores_before or [])
+        new_sum = sum(proposal.subsample_scores_after or [])
+        return new_sum >= old_sum

package/vendor/gepa-python/src/gepa/strategies/batch_sampler.py

@@ -0,0 +1,103 @@
+# Copyright (c) 2025 Lakshya A Agrawal and the GEPA contributors
+# https://github.com/gepa-ai/gepa
+
+import random
+from collections import Counter
+from typing import Protocol
+
+from gepa.core.adapter import DataInst
+from gepa.core.data_loader import DataId, DataLoader
+from gepa.core.state import GEPAState
+
+
+class BatchSampler(Protocol[DataId, DataInst]):
+    """Yields the minibatch of trainset ids to propose from.
+
+    Multi-proposal sampling strategies call ``next_minibatch_ids`` once per
+    task within a single iteration (``state.i`` unchanged between calls).
+    Implementations should return a *different* minibatch on each repeated
+    call within an iteration, so parallel proposal tasks don't all share one
+    minibatch.
+    """
+
+    def next_minibatch_ids(self, loader: DataLoader[DataId, DataInst], state: GEPAState) -> list[DataId]: ...
+
+
+class EpochShuffledBatchSampler(BatchSampler[DataId, DataInst]):
+    """
+    Mirrors the original batching logic:
+    - Shuffle ids each epoch
+    - Pad to minibatch size with least frequent ids
+    - Deterministic via state.rng1
+    """
+
+    def __init__(self, minibatch_size: int, rng: random.Random | None = None):
+        self.minibatch_size = minibatch_size
+        self.shuffled_ids: list[DataId] = []
+        self.epoch = -1
+        self.id_freqs = Counter()
+        self.last_trainset_size = 0
+        self._current_iteration: int | None = None
+        self._calls_in_iteration = 0
+        if rng is None:
+            self.rng = random.Random(0)
+        else:
+            self.rng = rng
+
+    def _update_shuffled(self, loader: DataLoader[DataId, DataInst]):
+        all_ids = list(loader.all_ids())
+        trainset_size = len(loader)
+        self.last_trainset_size = trainset_size
+
+        if trainset_size == 0:
+            self.shuffled_ids = []
+            self.id_freqs = Counter()
+            return
+
+        self.shuffled_ids = list(all_ids)
+        self.rng.shuffle(self.shuffled_ids)
+        self.id_freqs = Counter(self.shuffled_ids)
+
+        mod = trainset_size % self.minibatch_size
+        num_to_pad = (self.minibatch_size - mod) if mod != 0 else 0
+        if num_to_pad > 0:
+            for _ in range(num_to_pad):
+                selected_id = self.id_freqs.most_common()[::-1][0][0]
+                self.shuffled_ids.append(selected_id)
+                self.id_freqs[selected_id] += 1
+
+    def next_minibatch_ids(self, loader: DataLoader[DataId, DataInst], state: GEPAState) -> list[DataId]:
+        trainset_size = len(loader)
+        if trainset_size == 0:
+            raise ValueError("Cannot sample a minibatch from an empty loader.")
+
+        # Repeated calls within one iteration (multi-proposal sampling
+        # strategies request one minibatch per task) advance one chunk each,
+        # so tasks in the same iteration get distinct minibatches. The first
+        # call of an iteration is unchanged from the classic behavior. Chunks
+        # wrap around, so distinctness holds only while the iteration's call
+        # count stays within len(shuffled_ids) / minibatch_size.
+        if state.i == self._current_iteration:
+            self._calls_in_iteration += 1
+        else:
+            self._current_iteration = state.i
+            self._calls_in_iteration = 0
+
+        base_idx = state.i * self.minibatch_size
+        curr_epoch = 0 if self.epoch == -1 else base_idx // max(len(self.shuffled_ids), 1)
+
+        needs_refresh = not self.shuffled_ids or trainset_size != self.last_trainset_size or curr_epoch > self.epoch
+        if needs_refresh:
+            self.epoch = curr_epoch
+            self._update_shuffled(loader)
+
+        assert len(self.shuffled_ids) >= self.minibatch_size
+        assert len(self.shuffled_ids) % self.minibatch_size == 0
+
+        # The epoch bookkeeping above uses the un-offset base_idx (constant
+        # within an iteration), so repeat calls never trigger a reshuffle and
+        # the shuffle sequence stays identical to the single-call path.
+        base_idx = (base_idx + self._calls_in_iteration * self.minibatch_size) % len(self.shuffled_ids)
+        end_idx = base_idx + self.minibatch_size
+        assert end_idx <= len(self.shuffled_ids)
+        return self.shuffled_ids[base_idx:end_idx]

package/vendor/gepa-python/src/gepa/strategies/candidate_selector.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2025 Lakshya A Agrawal and the GEPA contributors
+# https://github.com/gepa-ai/gepa
+
+import random
+
+from gepa.core.state import GEPAState
+from gepa.gepa_utils import idxmax, select_program_candidate_from_pareto_front
+from gepa.proposer.reflective_mutation.base import CandidateSelector
+
+
+class ParetoCandidateSelector(CandidateSelector):
+    def __init__(self, rng: random.Random | None):
+        if rng is None:
+            self.rng = random.Random(0)
+        else:
+            self.rng = rng
+
+    def select_candidate_idx(self, state: GEPAState) -> int:
+        assert len(state.program_full_scores_val_set) == len(state.program_candidates)
+        return select_program_candidate_from_pareto_front(
+            state.get_pareto_front_mapping(),
+            state.per_program_tracked_scores,
+            self.rng,
+        )
+
+
+class CurrentBestCandidateSelector(CandidateSelector):
+    def __init__(self):
+        pass
+
+    def select_candidate_idx(self, state: GEPAState) -> int:
+        assert len(state.program_full_scores_val_set) == len(state.program_candidates)
+        return idxmax(state.program_full_scores_val_set)
+
+
+class EpsilonGreedyCandidateSelector(CandidateSelector):
+    def __init__(self, epsilon: float, rng: random.Random | None):
+        assert 0.0 <= epsilon <= 1.0
+        self.epsilon = epsilon
+        if rng is None:
+            self.rng = random.Random(0)
+        else:
+            self.rng = rng
+
+    def select_candidate_idx(self, state: GEPAState) -> int:
+        assert len(state.program_full_scores_val_set) == len(state.program_candidates)
+        if self.rng.random() < self.epsilon:
+            return self.rng.randint(0, len(state.program_candidates) - 1)
+        else:
+            return idxmax(state.program_full_scores_val_set)
+
+
+class TopKParetoCandidateSelector(CandidateSelector):
+    """Pareto selection restricted to the top K programs by aggregate score."""
+
+    def __init__(self, k: int, rng: random.Random | None):
+        assert k > 0
+        self.k = k
+        if rng is None:
+            self.rng = random.Random(0)
+        else:
+            self.rng = rng
+
+    def select_candidate_idx(self, state: GEPAState) -> int:
+        assert len(state.program_full_scores_val_set) == len(state.program_candidates)
+        # Get top K program indices by aggregate score
+        scores = state.per_program_tracked_scores
+        top_k_indices = set(sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[: self.k])
+
+        # Filter pareto front mapping to only include top K programs
+        pareto_mapping = state.get_pareto_front_mapping()
+        filtered_mapping = {}
+        for key, prog_set in pareto_mapping.items():
+            filtered = prog_set & top_k_indices
+            if filtered:
+                filtered_mapping[key] = filtered
+
+        if not filtered_mapping:
+            # Fallback: pick the best program overall
+            return idxmax(scores)
+
+        return select_program_candidate_from_pareto_front(filtered_mapping, scores, self.rng)

package/vendor/gepa-python/src/gepa/strategies/component_selector.py

@@ -0,0 +1,36 @@
+# Copyright (c) 2025 Lakshya A Agrawal and the GEPA contributors
+# https://github.com/gepa-ai/gepa
+
+
+from gepa.core.adapter import Trajectory
+from gepa.core.state import GEPAState
+from gepa.proposer.reflective_mutation.base import ReflectionComponentSelector
+
+
+class RoundRobinReflectionComponentSelector(ReflectionComponentSelector):
+    def __call__(
+        self,
+        state: GEPAState,
+        trajectories: list[Trajectory],
+        subsample_scores: list[float],
+        candidate_idx: int,
+        candidate: dict[str, str],
+    ) -> list[str]:
+        pid = state.named_predictor_id_to_update_next_for_program_candidate[candidate_idx]
+        state.named_predictor_id_to_update_next_for_program_candidate[candidate_idx] = (pid + 1) % len(
+            state.list_of_named_predictors
+        )
+        name = state.list_of_named_predictors[pid]
+        return [name]
+
+
+class AllReflectionComponentSelector(ReflectionComponentSelector):
+    def __call__(
+        self,
+        state: GEPAState,
+        trajectories: list[Trajectory],
+        subsample_scores: list[float],
+        candidate_idx: int,
+        candidate: dict[str, str],
+    ) -> list[str]:
+        return list(candidate.keys())

package/vendor/gepa-python/src/gepa/strategies/eval_policy.py

@@ -0,0 +1,64 @@
+"""Validation evaluation policy protocols and helpers."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import Protocol, runtime_checkable
+
+from gepa.core.data_loader import DataId, DataInst, DataLoader
+from gepa.core.state import GEPAState, ProgramIdx
+
+
+@runtime_checkable
+class EvaluationPolicy(Protocol[DataId, DataInst]):  # type: ignore
+    """Strategy for choosing validation ids to evaluate and identifying best programs for validation instances."""
+
+    @abstractmethod
+    def get_eval_batch(
+        self, loader: DataLoader[DataId, DataInst], state: GEPAState, target_program_idx: ProgramIdx | None = None
+    ) -> list[DataId]:
+        """Select examples for evaluation for a program"""
+        ...
+
+    @abstractmethod
+    def get_best_program(self, state: GEPAState) -> ProgramIdx:
+        """Return "best" program given all validation results so far across candidates"""
+        ...
+
+    @abstractmethod
+    def get_valset_score(self, program_idx: ProgramIdx, state: GEPAState) -> float:
+        """Return the score of the program on the valset"""
+        ...
+
+
+class FullEvaluationPolicy(EvaluationPolicy[DataId, DataInst]):
+    """Policy that evaluates all validation instances every time."""
+
+    def get_eval_batch(
+        self, loader: DataLoader[DataId, DataInst], state: GEPAState, target_program_idx: ProgramIdx | None = None
+    ) -> list[DataId]:
+        """Always return the full ordered list of validation ids."""
+        return list(loader.all_ids())
+
+    def get_best_program(self, state: GEPAState) -> ProgramIdx:
+        """Pick the program whose evaluated validation scores achieve the highest average."""
+        best_idx, best_score, best_coverage = -1, float("-inf"), -1
+        for program_idx, scores in enumerate(state.prog_candidate_val_subscores):
+            coverage = len(scores)
+            avg = sum(scores.values()) / coverage if coverage else float("-inf")
+            if avg > best_score or (avg == best_score and coverage > best_coverage):
+                best_score = avg
+                best_idx = program_idx
+                best_coverage = coverage
+        return best_idx
+
+    def get_valset_score(self, program_idx: ProgramIdx, state: GEPAState) -> float:
+        """Return the score of the program on the valset"""
+        return state.get_program_average_val_subset(program_idx)[0]
+
+
+__all__ = [
+    "DataLoader",
+    "EvaluationPolicy",
+    "FullEvaluationPolicy",
+]

package/vendor/gepa-python/src/gepa/strategies/instruction_proposal.py

@@ -0,0 +1,153 @@
+# Copyright (c) 2025 Lakshya A Agrawal and the GEPA contributors
+# https://github.com/gepa-ai/gepa
+
+import re
+from collections.abc import Mapping, Sequence
+from typing import Any, ClassVar
+
+from gepa.image import Image
+from gepa.proposer.reflective_mutation.base import Signature
+
+
+class InstructionProposalSignature(Signature):
+    default_prompt_template = """I provided an assistant with the following instructions to perform a task for me:
+```
+<curr_param>
+```
+
+The following are examples of different task inputs provided to the assistant along with the assistant's response for each of them, and some feedback on how the assistant's response could be better:
+```
+<side_info>
+```
+
+Your task is to write a new instruction for the assistant.
+
+Read the inputs carefully and identify the input format and infer detailed task description about the task I wish to solve with the assistant.
+
+Read all the assistant responses and the corresponding feedback. Identify all niche and domain specific factual information about the task and include it in the instruction, as a lot of it may not be available to the assistant in the future. The assistant may have utilized a generalizable strategy to solve the task, if so, include that in the instruction as well.
+
+Provide the new instructions within ``` blocks."""
+
+    input_keys: ClassVar[list[str]] = ["current_instruction_doc", "dataset_with_feedback", "prompt_template"]
+    output_keys: ClassVar[list[str]] = ["new_instruction"]
+
+    @classmethod
+    def validate_prompt_template(cls, prompt_template: str | None) -> None:
+        if prompt_template is None:
+            return
+        missing_placeholders = [
+            placeholder for placeholder in ("<curr_param>", "<side_info>") if placeholder not in prompt_template
+        ]
+        if missing_placeholders:
+            raise ValueError(f"Missing placeholder(s) in prompt template: {', '.join(missing_placeholders)}")
+
+    @classmethod
+    def prompt_renderer(cls, input_dict: Mapping[str, Any]) -> str | list[dict[str, Any]]:
+        current_instruction = input_dict.get("current_instruction_doc")
+        if not isinstance(current_instruction, str):
+            raise TypeError("current_instruction_doc must be a string")
+
+        dataset = input_dict.get("dataset_with_feedback")
+        if not isinstance(dataset, Sequence) or isinstance(dataset, str | bytes):
+            raise TypeError("dataset_with_feedback must be a sequence of records")
+
+        def format_samples(samples: Sequence[Mapping[str, Any]]) -> tuple[str, list[Image]]:
+            """Render samples as markdown, extracting any Image objects.
+
+            Returns:
+                A tuple of (formatted_text, collected_images).  Image objects
+                are replaced with ``[IMAGE-N]`` placeholders in the text.
+            """
+            collected_images: list[Image] = []
+
+            def render_value(value: Any, level: int = 3) -> str:
+                # level controls markdown header depth (###, ####, etc.)
+                if isinstance(value, Image):
+                    collected_images.append(value)
+                    return f"[IMAGE-{len(collected_images)} — see visual content]\n\n"
+                elif isinstance(value, dict):
+                    s = ""
+                    for k, v in value.items():
+                        s += f"{'#' * level} {k}\n"
+                        s += render_value(v, min(level + 1, 6))
+                    if not value:
+                        s += "\n"
+                    return s
+                elif isinstance(value, list | tuple):
+                    s = ""
+                    for i, item in enumerate(value):
+                        s += f"{'#' * level} Item {i + 1}\n"
+                        s += render_value(item, min(level + 1, 6))
+                    if not value:
+                        s += "\n"
+                    return s
+                else:
+                    return f"{str(value).strip()}\n\n"
+
+            def convert_sample_to_markdown(sample: Mapping[str, Any], examplenum: int) -> str:
+                s = f"# Example {examplenum}\n"
+                for key, val in sample.items():
+                    s += f"## {key}\n"
+                    s += render_value(val, level=3)
+                return s
+
+            text = "\n\n".join(convert_sample_to_markdown(sample, i + 1) for i, sample in enumerate(samples))
+            return text, collected_images
+
+        prompt_template = input_dict.get("prompt_template")
+        if prompt_template is None:
+            prompt_template = cls.default_prompt_template
+
+        cls.validate_prompt_template(prompt_template)
+
+        formatted_text, images = format_samples(dataset)
+
+        if images:
+            formatted_text = (
+                f"The evaluation data below includes visual content ({len(images)} image(s)). "
+                "Analyze both the text and images when suggesting improvements.\n\n" + formatted_text
+            )
+
+        prompt = prompt_template.replace("<curr_param>", current_instruction)
+        prompt = prompt.replace("<side_info>", formatted_text)
+
+        # When images are present, return an OpenAI-compatible multimodal
+        # messages list so the reflection LM receives the images inline.
+        if images:
+            content: list[dict[str, Any]] = [{"type": "text", "text": prompt}]
+            for img in images:
+                content.append(img.to_openai_content_part())
+            return [{"role": "user", "content": content}]
+
+        return prompt
+
+    @classmethod
+    def output_extractor(cls, lm_out: str) -> dict[str, str]:
+        def extract_instruction_text() -> str:
+            # Find the first and last backtick positions (if any)
+            start = lm_out.find("```") + 3
+            end = lm_out.rfind("```")
+
+            # Handle if the first and last backticks are the same or overlap
+            if start >= end:
+                # Handle incomplete blocks
+                stripped = lm_out.strip()
+                if stripped.startswith("```"):
+                    # Remove opening ``` and optional language specifier
+                    match = re.match(r"^```\S*\n?", lm_out)
+                    if match:
+                        return lm_out[match.end() :].strip()
+                elif stripped.endswith("```"):
+                    # Remove closing ```
+                    return stripped[:-3].strip()
+                return stripped
+
+            # Skip optional language specifier
+            content = lm_out[start:end]
+            match = re.match(r"^\S*\n", content)
+            if match:
+                content = content[match.end() :]
+
+            return content.strip()
+
+        return {"new_instruction": extract_instruction_text()}

package/vendor/gepa-python/src/gepa/strategies/proposal_sampling.py

@@ -0,0 +1,128 @@
+# Copyright (c) 2025 Lakshya A Agrawal and the GEPA contributors
+# https://github.com/gepa-ai/gepa
+
+"""Sampling strategies for selecting (parent, minibatch) pairs each iteration."""
+
+from dataclasses import dataclass
+from typing import Generic, Protocol
+
+from gepa.core.data_loader import DataId, DataInst, DataLoader
+from gepa.core.state import GEPAState
+from gepa.proposer.reflective_mutation.base import CandidateSelector
+from gepa.strategies.batch_sampler import BatchSampler
+
+
+@dataclass
+class ProposalTask(Generic[DataId, DataInst]):
+    """One (parent, minibatch) pair to propose from."""
+
+    parent_idx: int
+    parent_candidate: dict[str, str]
+    minibatch_ids: list[DataId]
+    minibatch: list[DataInst]
+
+
+class SamplingStrategy(Protocol[DataId, DataInst]):
+    """Generates one or more (parent, minibatch) tasks per iteration.
+
+    The default (``SingleMutationSampling``) produces exactly one task,
+    matching GEPA's original sequential behavior.  Swap in a different
+    strategy to propose multiple candidates per iteration.
+
+    Note on trainset size: multi-task strategies draw ``n`` minibatches from
+    the epoch-shuffled sampler per iteration. When
+    ``n * minibatch_size > len(trainset)`` the sampler wraps around within the
+    iteration, so some tasks will receive repeated minibatches. This is safe
+    but reduces the diversity benefit — prefer ``n <= len(trainset) //
+    minibatch_size``.
+    """
+
+    def sample_tasks(
+        self,
+        state: GEPAState,
+        candidate_selector: CandidateSelector,
+        batch_sampler: BatchSampler[DataId, DataInst],
+        trainset: DataLoader[DataId, DataInst],
+    ) -> list[ProposalTask[DataId, DataInst]]: ...
+
+
+class SingleMutationSampling(SamplingStrategy):
+    """1 parent, 1 mutation — default GEPA behavior."""
+
+    def sample_tasks(
+        self,
+        state: GEPAState,
+        candidate_selector: CandidateSelector,
+        batch_sampler: BatchSampler,
+        trainset: DataLoader,
+    ) -> list[ProposalTask]:
+        parent_idx = candidate_selector.select_candidate_idx(state)
+        mb_ids = batch_sampler.next_minibatch_ids(trainset, state)
+        return [ProposalTask(parent_idx, state.program_candidates[parent_idx], mb_ids, trainset.fetch(mb_ids))]
+
+
+class SameParentSampling(SamplingStrategy):
+    """Best-of-N on the same parent with different minibatches."""
+
+    def __init__(self, n: int):
+        self.n = n
+
+    def sample_tasks(
+        self,
+        state: GEPAState,
+        candidate_selector: CandidateSelector,
+        batch_sampler: BatchSampler,
+        trainset: DataLoader,
+    ) -> list[ProposalTask]:
+        parent_idx = candidate_selector.select_candidate_idx(state)
+        parent = state.program_candidates[parent_idx]
+        tasks = []
+        for _ in range(self.n):
+            mb_ids = batch_sampler.next_minibatch_ids(trainset, state)
+            tasks.append(ProposalTask(parent_idx, parent, mb_ids, trainset.fetch(mb_ids)))
+        return tasks
+
+
+class IndependentSampling(SamplingStrategy):
+    """N different parents, each with their own minibatch."""
+
+    def __init__(self, n: int):
+        self.n = n
+
+    def sample_tasks(
+        self,
+        state: GEPAState,
+        candidate_selector: CandidateSelector,
+        batch_sampler: BatchSampler,
+        trainset: DataLoader,
+    ) -> list[ProposalTask]:
+        tasks = []
+        for _ in range(self.n):
+            parent_idx = candidate_selector.select_candidate_idx(state)
+            mb_ids = batch_sampler.next_minibatch_ids(trainset, state)
+            tasks.append(ProposalTask(parent_idx, state.program_candidates[parent_idx], mb_ids, trainset.fetch(mb_ids)))
+        return tasks
+
+
+class PxNSampling(SamplingStrategy):
+    """P parents x N mutations each = P*N total tasks."""
+
+    def __init__(self, p: int, n: int):
+        self.p = p
+        self.n = n
+
+    def sample_tasks(
+        self,
+        state: GEPAState,
+        candidate_selector: CandidateSelector,
+        batch_sampler: BatchSampler,
+        trainset: DataLoader,
+    ) -> list[ProposalTask]:
+        tasks = []
+        for _ in range(self.p):
+            parent_idx = candidate_selector.select_candidate_idx(state)
+            parent = state.program_candidates[parent_idx]
+            for _ in range(self.n):
+                mb_ids = batch_sampler.next_minibatch_ids(trainset, state)
+                tasks.append(ProposalTask(parent_idx, parent, mb_ids, trainset.fetch(mb_ids)))
+        return tasks