fabricatio 0.2.3.dev1__tar.gz → 0.2.3.dev3__tar.gz

{fabricatio-0.2.3.dev1 → fabricatio-0.2.3.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.3.dev1
+Version: 0.2.3.dev3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -98,32 +98,32 @@ from fabricatio import Action, Role, Task, logger
 
 
 class Hello(Action):
-    """Action that says hello."""
+   """Action that says hello."""
 
-    name: str = "hello"
-    output_key: str = "task_output"
+   name: str = "hello"
+   output_key: str = "task_output"
 
-    async def _execute(self, task_input: Task[str], **_) -> Any:
-        ret = "Hello fabricatio!"
-        logger.info("executing talk action")
-        return ret
+   async def _execute(self, task_input: Task[str], **_) -> Any:
+      ret = "Hello fabricatio!"
+      logger.info("executing talk action")
+      return ret
 
 
 async def main() -> None:
-    """Main function."""
-    role = Role(
-        name="talker", 
-        description="talker role", 
-        registry={Task.pending_label: WorkFlow(name="talk", steps=(Hello,))}
-    )
+   """Main function."""
+   role = Role(
+      name="talker",
+      description="talker role",
+      registry={Task.pending_label: WorkFlow(name="talk", steps=(Hello,))}
+   )
 
-    task = Task(name="say hello", goal="say hello", description="say hello to the world")
-    result = await task.delegate()
-    logger.success(f"Result: {result}")
+   task = Task(name="say hello", goals="say hello", description="say hello to the world")
+   result = await task.delegate()
+   logger.success(f"Result: {result}")
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+   asyncio.run(main())
 ```
 
 #### Writing and Dumping Code
@@ -311,17 +311,18 @@ from fabricatio.models.task import Task
 
 toolbox_usage = ToolBoxUsage()
 
+
 async def handle_security_vulnerabilities():
-    task = Task(
-        name="Security Check",
-        goal=["Identify security vulnerabilities"],
-        description="Perform a thorough security review on the project.",
-        dependencies=["./src/main.py"]
-    )
-    
-    vulnerabilities = await toolbox_usage.gather_tools_fine_grind(task)
-    for vulnerability in vulnerabilities:
-        print(f"Found vulnerability: {vulnerability.name}")
+   task = Task(
+      name="Security Check",
+      goals=["Identify security vulnerabilities"],
+      description="Perform a thorough security review on the project.",
+      dependencies=["./src/main.py"]
+   )
+
+   vulnerabilities = await toolbox_usage.gather_tools_fine_grind(task)
+   for vulnerability in vulnerabilities:
+      print(f"Found vulnerability: {vulnerability.name}")
 ```
 
 #### Managing CTF Challenges
@@ -334,19 +335,22 @@ from fabricatio.models.task import Task
 
 toolbox_usage = ToolBoxUsage()
 
+
 async def solve_ctf_challenge(challenge_name: str, challenge_description: str, files: list[str]):
-    task = Task(
-        name=challenge_name,
-        goal=[f"Solve {challenge_name} challenge"],
-        description=challenge_description,
-        dependencies=files
-    )
-    
-    solution = await toolbox_usage.gather_tools_fine_grind(task)
-    print(f"Challenge Solved: {solution}")
+   task = Task(
+      name=challenge_name,
+      goals=[f"Solve {challenge_name} challenge"],
+      description=challenge_description,
+      dependencies=files
+   )
+
+   solution = await toolbox_usage.gather_tools_fine_grind(task)
+   print(f"Challenge Solved: {solution}")
+
 
 if __name__ == "__main__":
-    asyncio.run(solve_ctf_challenge("Binary Exploitation", "CTF Binary Exploitation Challenge", ["./challenges/binary_exploit"]))
+   asyncio.run(
+      solve_ctf_challenge("Binary Exploitation", "CTF Binary Exploitation Challenge", ["./challenges/binary_exploit"]))
 ```
 
 ### Configuration

{fabricatio-0.2.3.dev1 → fabricatio-0.2.3.dev3}/README.md

@@ -59,32 +59,32 @@ from fabricatio import Action, Role, Task, logger
 
 
 class Hello(Action):
-    """Action that says hello."""
+   """Action that says hello."""
 
-    name: str = "hello"
-    output_key: str = "task_output"
+   name: str = "hello"
+   output_key: str = "task_output"
 
-    async def _execute(self, task_input: Task[str], **_) -> Any:
-        ret = "Hello fabricatio!"
-        logger.info("executing talk action")
-        return ret
+   async def _execute(self, task_input: Task[str], **_) -> Any:
+      ret = "Hello fabricatio!"
+      logger.info("executing talk action")
+      return ret
 
 
 async def main() -> None:
-    """Main function."""
-    role = Role(
-        name="talker", 
-        description="talker role", 
-        registry={Task.pending_label: WorkFlow(name="talk", steps=(Hello,))}
-    )
+   """Main function."""
+   role = Role(
+      name="talker",
+      description="talker role",
+      registry={Task.pending_label: WorkFlow(name="talk", steps=(Hello,))}
+   )
 
-    task = Task(name="say hello", goal="say hello", description="say hello to the world")
-    result = await task.delegate()
-    logger.success(f"Result: {result}")
+   task = Task(name="say hello", goals="say hello", description="say hello to the world")
+   result = await task.delegate()
+   logger.success(f"Result: {result}")
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+   asyncio.run(main())
 ```
 
 #### Writing and Dumping Code
@@ -272,17 +272,18 @@ from fabricatio.models.task import Task
 
 toolbox_usage = ToolBoxUsage()
 
+
 async def handle_security_vulnerabilities():
-    task = Task(
-        name="Security Check",
-        goal=["Identify security vulnerabilities"],
-        description="Perform a thorough security review on the project.",
-        dependencies=["./src/main.py"]
-    )
-    
-    vulnerabilities = await toolbox_usage.gather_tools_fine_grind(task)
-    for vulnerability in vulnerabilities:
-        print(f"Found vulnerability: {vulnerability.name}")
+   task = Task(
+      name="Security Check",
+      goals=["Identify security vulnerabilities"],
+      description="Perform a thorough security review on the project.",
+      dependencies=["./src/main.py"]
+   )
+
+   vulnerabilities = await toolbox_usage.gather_tools_fine_grind(task)
+   for vulnerability in vulnerabilities:
+      print(f"Found vulnerability: {vulnerability.name}")
 ```
 
 #### Managing CTF Challenges
@@ -295,19 +296,22 @@ from fabricatio.models.task import Task
 
 toolbox_usage = ToolBoxUsage()
 
+
 async def solve_ctf_challenge(challenge_name: str, challenge_description: str, files: list[str]):
-    task = Task(
-        name=challenge_name,
-        goal=[f"Solve {challenge_name} challenge"],
-        description=challenge_description,
-        dependencies=files
-    )
-    
-    solution = await toolbox_usage.gather_tools_fine_grind(task)
-    print(f"Challenge Solved: {solution}")
+   task = Task(
+      name=challenge_name,
+      goals=[f"Solve {challenge_name} challenge"],
+      description=challenge_description,
+      dependencies=files
+   )
+
+   solution = await toolbox_usage.gather_tools_fine_grind(task)
+   print(f"Challenge Solved: {solution}")
+
 
 if __name__ == "__main__":
-    asyncio.run(solve_ctf_challenge("Binary Exploitation", "CTF Binary Exploitation Challenge", ["./challenges/binary_exploit"]))
+   asyncio.run(
+      solve_ctf_challenge("Binary Exploitation", "CTF Binary Exploitation Challenge", ["./challenges/binary_exploit"]))
 ```
 
 ### Configuration

{fabricatio-0.2.3.dev1 → fabricatio-0.2.3.dev3}/examples/make_diary/diary.py

@@ -18,8 +18,8 @@ class WriteDiary(Action):
     output_key: str = "dump_text"
 
     async def _execute(self, task_input: Task[str], **_) -> str:
-        task_input.goal.clear()
-        task_input.goal.extend(
+        task_input.goals.clear()
+        task_input.goals.extend(
             [
                 "write a Internship Diary according to the given commit messages",
                 "the diary should include the main dev target of the day, and the exact content"

{fabricatio-0.2.3.dev1 → fabricatio-0.2.3.dev3}/examples/minor/hello_fabricatio.py

@@ -5,7 +5,7 @@ from typing import Any
 
 from fabricatio import Action, Role, Task, WorkFlow, logger
 
-task = Task(name="say hello", goal=["say hello"], description="say hello to the world")
+task = Task(name="say hello", goals=["say hello"], description="say hello to the world")
 
 
 class Hello(Action):

{fabricatio-0.2.3.dev1 → fabricatio-0.2.3.dev3}/examples/propose_task/propose.py

@@ -5,7 +5,7 @@ from typing import Any
 
 from fabricatio import Action, Role, Task, WorkFlow, logger
 
-task = Task(name="say hello", goal=["say hello"], description="say hello to the world")
+task = Task(name="say hello", goals=["say hello"], description="say hello to the world")
 
 
 class Talk(Action):

fabricatio-0.2.3.dev3/examples/simple_chat/chat.py

@@ -0,0 +1,47 @@
+"""Simple chat example."""
+
+import asyncio
+
+from fabricatio import Action, Role, Task, WorkFlow, logger
+from fabricatio.models.events import Event
+from questionary import text
+
+
+class Talk(Action):
+    """Action that says hello to the world."""
+
+    name: str = "talk"
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **_) -> int:
+        counter = 0
+        try:
+            while True:
+                user_say = await text("User: ").ask_async()
+                gpt_say = await self.aask(
+                    user_say,
+                    system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}",
+                )
+                print(f"GPT: {gpt_say}")  # noqa: T201
+                counter += 1
+        except KeyboardInterrupt:
+            logger.info(f"executed talk action {counter} times")
+        return counter
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="talker",
+        description="talker role",
+        registry={Event.instantiate_from("talk").push_wildcard().push("pending"): WorkFlow(name="talk", steps=(Talk,))},
+    )
+
+    task = await role.propose(
+        "you have to act as a helpful assistant, answer to all user questions properly and patiently"
+    )
+    _ = await task.delegate("talk")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fabricatio-0.2.3.dev1/examples/simple_chat/chat.py → fabricatio-0.2.3.dev3/examples/simple_rag/simple_rag.py

@@ -5,7 +5,7 @@ from typing import Any
 
 from fabricatio import Action, Role, Task, WorkFlow, logger
 
-task = Task(name="say hello", goal=["say hello"], description="say hello to the world")
+task = Task(name="say hello", goals=["say hello"], description="say hello to the world")
 
 
 class Talk(Action):

{fabricatio-0.2.3.dev1 → fabricatio-0.2.3.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.3-dev1"
+version = "0.2.3-dev3"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

{fabricatio-0.2.3.dev1 → fabricatio-0.2.3.dev3}/python/fabricatio/__init__.py

@@ -1,5 +1,7 @@
 """Fabricatio is a Python library for building llm app using event-based agent structure."""
 
+from importlib.util import find_spec
+
 from fabricatio._rust_instances import template_manager
 from fabricatio.core import env
 from fabricatio.fs import magika
@@ -35,3 +37,9 @@ __all__ = [
     "task_toolbox",
     "template_manager",
 ]
+
+
+if find_spec("pymilvus"):
+    from fabricatio.capabilities.rag import Rag
+
+    __all__ += ["Rag"]

fabricatio-0.2.3.dev3/python/fabricatio/capabilities/rag.py

@@ -0,0 +1,225 @@
+"""A module for the RAG (Retrieval Augmented Generation) model."""
+
+from functools import lru_cache
+from operator import itemgetter
+from os import PathLike
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Self, Union, Unpack
+
+from fabricatio import template_manager
+from fabricatio.config import configs
+from fabricatio.models.kwargs_types import LLMKwargs
+from fabricatio.models.usages import LLMUsage
+from fabricatio.models.utils import MilvusData
+from more_itertools.recipes import flatten
+
+try:
+    from pymilvus import MilvusClient
+except ImportError as e:
+    raise RuntimeError("pymilvus is not installed. Have you installed `fabricatio[rag]` instead of `fabricatio`") from e
+from pydantic import Field, PrivateAttr
+
+
+@lru_cache(maxsize=None)
+def create_client(
+    uri: Optional[str] = None, token: Optional[str] = None, timeout: Optional[float] = None
+) -> MilvusClient:
+    """Create a Milvus client."""
+    return MilvusClient(
+        uri=uri or configs.rag.milvus_uri.unicode_string(),
+        token=token or configs.rag.milvus_token.get_secret_value() if configs.rag.milvus_token else "",
+        timeout=timeout or configs.rag.milvus_timeout,
+    )
+
+
+class Rag(LLMUsage):
+    """A class representing the RAG (Retrieval Augmented Generation) model."""
+
+    milvus_uri: Optional[str] = Field(default=None, frozen=True)
+    """The URI of the Milvus server."""
+    milvus_token: Optional[str] = Field(default=None, frozen=True)
+    """The token for the Milvus server."""
+    milvus_timeout: Optional[float] = Field(default=None, frozen=True)
+    """The timeout for the Milvus server."""
+    target_collection: Optional[str] = Field(default=None)
+    """The name of the collection being viewed."""
+
+    _client: MilvusClient = PrivateAttr(None)
+    """The Milvus client used for the RAG model."""
+
+    @property
+    def client(self) -> MilvusClient:
+        """Return the Milvus client."""
+        return self._client
+
+    def model_post_init(self, __context: Any) -> None:
+        """Initialize the RAG model by creating the collection if it does not exist."""
+        self._client = create_client(self.milvus_uri, self.milvus_token, self.milvus_timeout)
+        self.view(self.target_collection, create=True)
+
+    def view(self, collection_name: Optional[str], create: bool = False) -> Self:
+        """View the specified collection.
+
+        Args:
+            collection_name (str): The name of the collection.
+            create (bool): Whether to create the collection if it does not exist.
+        """
+        if create and collection_name and not self._client.has_collection(collection_name):
+            self._client.create_collection(collection_name)
+
+        self.target_collection = collection_name
+        return self
+
+    def quit_viewing(self) -> Self:
+        """Quit the current view.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        return self.view(None)
+
+    @property
+    def safe_target_collection(self) -> str:
+        """Get the name of the collection being viewed, raise an error if not viewing any collection.
+
+        Returns:
+            str: The name of the collection being viewed.
+        """
+        if self.target_collection is None:
+            raise RuntimeError("No collection is being viewed. Have you called `self.view()`?")
+        return self.target_collection
+
+    def add_document[D: Union[Dict[str, Any], MilvusData]](
+        self, data: D | List[D], collection_name: Optional[str] = None
+    ) -> Self:
+        """Adds a document to the specified collection.
+
+        Args:
+            data (Union[Dict[str, Any], MilvusData] | List[Union[Dict[str, Any], MilvusData]]): The data to be added to the collection.
+            collection_name (Optional[str]): The name of the collection. If not provided, the currently viewed collection is used.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        if isinstance(data, MilvusData):
+            data = data.prepare_insertion()
+        if isinstance(data, list):
+            data = [d.prepare_insertion() if isinstance(d, MilvusData) else d for d in data]
+        self._client.insert(collection_name or self.safe_target_collection, data)
+        return self
+
+    def consume(
+        self, source: PathLike, reader: Callable[[PathLike], MilvusData], collection_name: Optional[str] = None
+    ) -> Self:
+        """Consume a file and add its content to the collection.
+
+        Args:
+            source (PathLike): The path to the file to be consumed.
+            reader (Callable[[PathLike], MilvusData]): The reader function to read the file.
+            collection_name (Optional[str]): The name of the collection. If not provided, the currently viewed collection is used.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        data = reader(Path(source))
+        self.add_document(data, collection_name or self.safe_target_collection)
+        return self
+
+    async def afetch_document(
+        self,
+        vecs: List[List[float]],
+        desired_fields: List[str] | str,
+        collection_name: Optional[str] = None,
+        result_per_query: int = 10,
+    ) -> List[Dict[str, Any]] | List[Any]:
+        """Fetch data from the collection.
+
+        Args:
+            vecs (List[List[float]]): The vectors to search for.
+            desired_fields (List[str] | str): The fields to retrieve.
+            collection_name (Optional[str]): The name of the collection. If not provided, the currently viewed collection is used.
+            result_per_query (int): The number of results to return per query.
+
+        Returns:
+            List[Dict[str, Any]] | List[Any]: The retrieved data.
+        """
+        # Step 1: Search for vectors
+        search_results = self._client.search(
+            collection_name or self.safe_target_collection,
+            vecs,
+            output_fields=desired_fields if isinstance(desired_fields, list) else [desired_fields],
+            limit=result_per_query,
+        )
+
+        # Step 2: Flatten the search results
+        flattened_results = flatten(search_results)
+
+        # Step 3: Sort by distance (descending)
+        sorted_results = sorted(flattened_results, key=itemgetter("distance"), reverse=True)
+
+        # Step 4: Extract the entities
+        resp = [result["entity"] for result in sorted_results]
+
+        if isinstance(desired_fields, list):
+            return resp
+        return [r.get(desired_fields) for r in resp]
+
+    async def aretrieve(
+        self,
+        query: List[str] | str,
+        collection_name: Optional[str] = None,
+        result_per_query: int = 10,
+        final_limit: int = 20,
+    ) -> List[str]:
+        """Retrieve data from the collection.
+
+        Args:
+            query (List[str] | str): The query to be used for retrieval.
+            collection_name (Optional[str]): The name of the collection. If not provided, the currently viewed collection is used.
+            result_per_query (int): The number of results to be returned per query.
+            final_limit (int): The final limit on the number of results to return.
+
+        Returns:
+            List[str]: A list of strings containing the retrieved data.
+        """
+        if isinstance(query, str):
+            query = [query]
+        return await self.afetch_document(
+            vecs=(await self.vectorize(query)),
+            desired_fields="text",
+            collection_name=collection_name,
+            result_per_query=result_per_query,
+        )[:final_limit]
+
+    async def aask_retrieved(
+        self,
+        question: str | List[str],
+        query: List[str] | str,
+        collection_name: Optional[str] = None,
+        result_per_query: int = 10,
+        final_limit: int = 20,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> str:
+        """Asks a question by retrieving relevant documents based on the provided query.
+
+        This method performs document retrieval using the given query, then asks the
+        specified question using the retrieved documents as context.
+
+        Args:
+            question (str | List[str]): The question or list of questions to be asked.
+            query (List[str] | str): The query or list of queries used for document retrieval.
+            collection_name (Optional[str]): The name of the collection to retrieve documents from.
+                                              If not provided, the currently viewed collection is used.
+            result_per_query (int): The number of results to return per query. Default is 10.
+            final_limit (int): The maximum number of retrieved documents to consider. Default is 20.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments passed to the underlying `aask` method.
+
+        Returns:
+            str: A string response generated after asking with the context of retrieved documents.
+        """
+        docs = await self.aretrieve(query, collection_name, result_per_query, final_limit)
+        return await self.aask(
+            question,
+            template_manager.render_template(configs.templates.retrieved_display_template, {"docs": docs}),
+            **kwargs,
+        )

{fabricatio-0.2.3.dev1 → fabricatio-0.2.3.dev3}/python/fabricatio/config.py

@@ -176,6 +176,9 @@ class TemplateConfig(BaseModel):
     draft_rating_weights_klee_template: str = Field(default="draft_rating_weights_klee")
     """The name of the draft rating weights klee template which will be used to draft rating weights with Klee method."""
 
+    retrieved_display_template: str = Field(default="retrieved_display")
+    """The name of the retrieved display template which will be used to display retrieved documents."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

{fabricatio-0.2.3.dev1 → fabricatio-0.2.3.dev3}/python/fabricatio/models/task.py

@@ -46,19 +46,19 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
     """
 
     name: str = Field(...)
-    """The name of the task, which should be a concise and descriptive name."""
+    """The name of the task, which should be concise and descriptive."""
 
     description: str = Field(default="")
-    """The description of the task, which should provide every details and noting about the task if provided, obeying the CEFR level rule and 5W1H rule."""
+    """A detailed explanation of the task that includes all necessary information. Should be clear and answer what, why, when, where, who, and how questions."""
 
-    goal: List[str] = Field(default=[])
-    """The goal of the task, a list of strings. The goal should be a concise and clear statement of what the task is intended to achieve, goal SHALL NOT be too broad or too narrow."""
+    goals: List[str] = Field(default=[])
+    """A list of objectives that the task aims to accomplish. Each goal should be clear and specific. Complex tasks should be broken into multiple smaller goals."""
 
     namespace: List[str] = Field(default_factory=list)
-    """The namespace of the task, a list of namespace segment, as string, if it is not directly given out, it SHALL just be a empty list meaning `NOT ASSIGNED`"""
+    """A list of string segments that identify the task's location in the system. If not specified, defaults to an empty list."""
 
     dependencies: List[str] = Field(default_factory=list)
-    """A list of file paths, These file are needed to read or write to meet a specific requirement of this task, if it is not directly given out, it SHALL just be a empty list meaning `NOT ASSIGNED`"""
+    """A list of file paths that are needed (either reading or writing) to complete this task. If not specified, defaults to an empty list."""
 
     _output: Queue[T | None] = PrivateAttr(default_factory=Queue)
     """The output queue of the task."""
@@ -113,7 +113,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         Returns:
             Task: A new instance of the `Task` class.
         """
-        return cls(name=name, goal=goal, description=description)
+        return cls(name=name, goals=goal, description=description)
 
     def update_task(self, goal: Optional[List[str] | str] = None, description: Optional[str] = None) -> Self:
         """Update the goal and description of the task.
@@ -126,7 +126,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
             Task: The updated instance of the `Task` class.
         """
         if goal:
-            self.goal = goal if isinstance(goal, list) else [goal]
+            self.goals = goal if isinstance(goal, list) else [goal]
         if description:
             self.description = description
         return self

fabricatio-0.2.3.dev3/templates/built-in/retrieved_display.hbs

@@ -0,0 +1,5 @@
+{{#if docs}}{{#each docs}}
+----- Start of {{ @index }}th retrieved document -----
+{{this}}
+----- End of {{ @index }}th retrieved document -----
+{{/each}}{{/if}}

{fabricatio-0.2.3.dev1 → fabricatio-0.2.3.dev3}/tests/test_models/test_action.py

@@ -1,5 +1,4 @@
 import pytest
-
 from fabricatio.models.action import Action, WorkFlow
 from fabricatio.models.task import Task, TaskStatus
 
@@ -103,7 +102,7 @@ def test_workflow_with_extra_context():
 @pytest.mark.asyncio
 async def test_workflow_serve_success():
     workflow = WorkFlow(name="TestServe", steps=[DemoAction()])
-    task = Task(name="test", goal=["test"], description="test")
+    task = Task(name="test", goals=["test"], description="test")
     await workflow.serve(task)
     assert task._status == TaskStatus.Finished
 
@@ -111,6 +110,6 @@ async def test_workflow_serve_success():
 @pytest.mark.asyncio
 async def test_workflow_serve_failure():
     workflow = WorkFlow(name="TestServeFail", steps=[FailingAction()])
-    task = Task(name="test", goal=["test"], description="test")
+    task = Task(name="test", goals=["test"], description="test")
     await workflow.serve(task)
     assert task