fabricatio 0.2.11.dev3__tar.gz → 0.2.12.dev1__tar.gz

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev1}/.gitignore

@@ -166,3 +166,5 @@ cython_debug/
 extra/scripts/*
 output/
 .vscode/
+templates/customed
+*.typ

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.11.dev3
+Version: 0.2.12.dev1
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

fabricatio-0.2.12.dev1/examples/write_article/.gitignore

@@ -0,0 +1,4 @@
+article_briefing.txt
+article_outline_raw.txt
+out.typ
+persistent*

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev1}/examples/write_article/write_article.py

@@ -6,25 +6,27 @@ from pathlib import Path
 import typer
 from fabricatio import Event, Role, WorkFlow, logger
 from fabricatio.actions.article import ExtractOutlineFromRaw, GenerateArticleProposal, GenerateInitialOutline
-from fabricatio.actions.article_rag import WriteArticleContentRAG
-from fabricatio.actions.output import (
-    DumpFinalizedOutput,
-    PersistentAll,
-)
+from fabricatio.actions.article_rag import ArticleConsultRAG, WriteArticleContentRAG
+from fabricatio.actions.output import DumpFinalizedOutput, PersistentAll
+from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.task import Task
 from fabricatio.utils import ok
 from typer import Typer
 
+# from pydantic import HttpUrl
+
 Role(
     name="Undergraduate Researcher",
     description="Write an outline for an article in typst format.",
-    llm_model="openai/qwen-max",
-    llm_temperature=0.63,
-    llm_stream=True,
-    llm_top_p=0.85,
+    llm_model="openai/qwen-plus",
+    llm_temperature=0.35,
+    # llm_api_endpoint=HttpUrl("https://dashscope.aliyuncs.com/compatible-mode/v1"),
+    llm_top_p=0.95,
     llm_max_tokens=8191,
+    llm_stream=True,
     llm_rpm=600,
-    llm_tpm=900000,
+    llm_tpm=1000000,
+    llm_timeout=600,
     registry={
         Event.quick_instantiate(ns := "article"): WorkFlow(
             name="Generate Article",
@@ -33,38 +35,46 @@ Role(
                 GenerateArticleProposal,
                 GenerateInitialOutline(output_key="article_outline"),
                 PersistentAll,
-                WriteArticleContentRAG(
-                    output_key="to_dump",
-                    llm_top_p=0.9,
-                    ref_limit=35,
-                    llm_model="openai/qwq-plus",
-                    target_collection="article_chunks",
-                    extractor_model="openai/qwen-plus",
-                    query_model="openai/qwen-max",
+                (
+                    a := WriteArticleContentRAG(
+                        output_key="to_dump",
+                        ref_limit=18,
+                        threshold=0.58,
+                        result_per_query=2,
+                        llm_model="openai/qwq-plus",
+                        extractor_model="openai/qwen-max",
+                        query_model="openai/qwen-turbo",
+                    )
                 ),
                 DumpFinalizedOutput(output_key="task_output"),
                 PersistentAll,
             ),
         ),
-        Event.quick_instantiate(ns2 := ""): WorkFlow(
+        Event.quick_instantiate(ns2 := "complete"): WorkFlow(
             name="Generate Article",
             description="Generate an article with given raw article outline. dump the outline to the given path. in typst format.",
             steps=(
-                ExtractOutlineFromRaw,
+                ExtractOutlineFromRaw(output_key="article_outline"),
                 PersistentAll,
-                WriteArticleContentRAG(
-                    output_key="to_dump",
-                    llm_top_p=0.9,
-                    ref_limit=35,
-                    llm_model="openai/qwq-plus",
-                    target_collection="article_chunks",
-                    extractor_model="openai/qwen-plus",
-                    query_model="openai/qwen-max",
-                ),
+                a,
                 DumpFinalizedOutput(output_key="task_output"),
                 PersistentAll,
             ),
         ),
+        Event.quick_instantiate(ns3 := "finish"): WorkFlow(
+            name="Finish Article",
+            description="Finish an article with given article outline. dump the outline to the given path. in typst format.",
+            steps=(
+                a,
+                DumpFinalizedOutput(output_key="task_output"),
+                PersistentAll,
+            ),
+        ),
+        Event.quick_instantiate(ns4 := "consult"): WorkFlow(
+            name="Consult Article",
+            description="Consult an article with given article outline. dump the outline to the given path. in typst format.",
+            steps=(ArticleConsultRAG().to_task_output(),),
+        ),
     },
 )
 
@@ -72,6 +82,52 @@ Role(
 app = Typer()
 
 
+@app.command()
+def consult(
+    collection_name: str = typer.Option("article_chunks", "-c", "--collection-name", help="Name of the collection."),
+) -> None:
+    """Consult an article based on a given article outline."""
+    _ = asyncio.run(
+        Task(name="Answer Question")
+        .update_init_context(
+            collection_name=collection_name,
+        )
+        .delegate(ns4)
+    )
+
+    logger.info("Finished")
+
+
+@app.command()
+def finish(
+    article_outline_path: Path = typer.Argument(  # noqa: B008
+        help="Path to the article outline raw file."
+    ),
+    dump_path: Path = typer.Option(Path("out.typ"), "-d", "--dump-path", help="Path to dump the final output."),  # noqa: B008
+    persist_dir: Path = typer.Option(  # noqa: B008
+        Path("persistent"), "-p", "--persist-dir", help="Directory to persist the output."
+    ),
+    collection_name: str = typer.Option("article_chunks", "-c", "--collection-name", help="Name of the collection."),
+    supervisor: bool = typer.Option(False, "-s", "--supervisor", help="Whether to use the supervisor mode."),
+) -> None:
+    """Finish an article based on a given article outline."""
+    path = ok(
+        asyncio.run(
+            Task(name="write an article")
+            .update_init_context(
+                article_outline=ArticleOutline.from_persistent(article_outline_path),
+                dump_path=dump_path,
+                persist_dir=persist_dir,
+                collection_name=collection_name,
+                supervisor=supervisor,
+            )
+            .delegate(ns3)
+        ),
+        "Failed to generate an article ",
+    )
+    logger.success(f"The outline is saved in:\n{path}")
+
+
 @app.command()
 def completion(
     article_outline_raw_path: Path = typer.Option(  # noqa: B008
@@ -95,7 +151,7 @@ def completion(
                 collection_name=collection_name,
                 supervisor=supervisor,
             )
-            .delegate(ns)
+            .delegate(ns2)
         ),
         "Failed to generate an article ",
     )

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.11-dev3"
+version = "0.2.12-dev1"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -137,7 +137,8 @@ ignore = [
     "PYI063",
     "PYI021",
     "ASYNC109",
-    "RUF001"
+    "RUF001",
+    "PYI019"
 ]
 [tool.ruff.lint.pydocstyle]
 convention = "google"

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev1}/python/fabricatio/actions/article_rag.py

@@ -4,6 +4,8 @@ from asyncio import gather
 from pathlib import Path
 from typing import List, Optional
 
+from pydantic import PositiveInt
+
 from fabricatio import BibManager
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.extract import Extract
@@ -18,13 +20,35 @@ from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.utils import ask_retain, ok
 
+TYPST_CITE_USAGE = (
+    "citation number is REQUIRED to cite any reference!,for example in Auther Pattern: 'Doe et al.[[1]], Jack et al.[[2]]' or in Sentence Suffix Sattern: 'Global requirement is incresing[[1]].'\n"
+    "Everything is build upon the typst language, which is similar to latex, \n"
+    "Legal citing syntax examples(seperated by |): [[1]]|[[1,2]]|[[1-3]]|[[12,13-15]]|[[1-3,5-7]]\n"
+    "Illegal citing syntax examples(seperated by |): [[1],[2],[3]]|[[1],[1-2]]\n"
+    "Those reference mark shall not be omitted during the extraction\n"
+    "It's recommended to cite multiple references that supports your conclusion at a time.\n"
+    "Wrapp inline expression using $ $,like '$>5m$' '$89%$' , and wrapp block equation using $$ $$. if you are using '$' as the money unit, you should add a '\\' before it to avoid being interpreted as a inline equation. For example 'The pants worths 5\\$.'\n"
+    "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>` like `<energy-release-rate-equation>`.Note that the label string should be a summarizing title for the equation being labeled.\n"
+    "you can refer to that label by using the syntax with prefix of `@eqt:`, which indicate that this notation is citing a label from the equations. For example ' @eqt:energy-release-rate-equation ' DO remember that the notation shall have both suffixed and prefixed space char which enable the compiler to distinguish the notation from the plaintext."
+    "Below is a usage example:\n"
+    "```typst\n"
+    "See @eqt:mass-energy-equation , it's the foundation of physics.\n"
+    "$$\n"
+    "E = m c^2\n"
+    "$$  <mass-energy-equation>\n\n\n"
+    "In @eqt:mass-energy-equation , $m$ stands for mass, $c$ stands for speed of light, and $E$ stands for energy. \n"
+    "```"
+)
+
 
 class WriteArticleContentRAG(Action, RAG, Extract):
     """Write an article based on the provided outline."""
 
+    search_increment_multiplier: float = 1.6
+    """The increment multiplier of the search increment."""
     ref_limit: int = 35
     """The limit of references to be retrieved"""
-    threshold: float = 0.55
+    threshold: float = 0.62
     """The threshold of relevance"""
     extractor_model: str
     """The model to use for extracting the content from the retrieved references."""
@@ -32,43 +56,24 @@ class WriteArticleContentRAG(Action, RAG, Extract):
     """The model to use for querying the database"""
     supervisor: bool = False
     """Whether to use supervisor mode"""
-    req: str = (
-        "citation number is REQUIRED to cite any reference!\n"
-        "Everything is build upon the typst language, which is similar to latex, \n"
-        "Legal citing syntax examples(seperated by |): [[1]]|[[1,2]]|[[1-3]]|[[12,13-15]]|[[1-3,5-7]]\n"
-        "Illegal citing syntax examples(seperated by |): [[1],[2],[3]]|[[1],[1-2]]\n"
-        "Those reference mark shall not be omitted during the extraction\n"
-        "It's recommended to cite multiple references that supports your conclusion at a time.\n"
-        "Wrapp inline expression using $ $, and wrapp block equation using $$ $$."
-        "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>`,"
-        "you can refer to that label by using the syntax with prefix of `@eqt:`"
-        "Below is a usage example:\n"
-        "```typst\n"
-        "See @eqt:mass-energy-equation , it's the foundation of physics.\n"
-        "$$\n"
-        "E = m c^2"
-        "$$\n"
-        "<mass-energy-equation>\n\n"
-        "In @eqt:mass-energy-equation , $m$ stands for mass, $c$ stands for speed of light, and $E$ stands for energy. \n"
-        "```"
-    )
+    result_per_query: PositiveInt = 4
+    """The number of results to be returned per query."""
+    req: str = TYPST_CITE_USAGE
+    """The req of the write article content."""
 
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        collection_name: str = "article_chunks",
+        collection_name: Optional[str] = None,
         supervisor: Optional[bool] = None,
         **cxt,
     ) -> Article:
         article = Article.from_outline(article_outline).update_ref(article_outline)
-
+        self.target_collection = collection_name or self.safe_target_collection
         if supervisor or (supervisor is None and self.supervisor):
-            await gather(
-                *[
-                    self._supervisor_inner(article, article_outline, chap, sec, subsec)
-                    for chap, sec, subsec in article.iter_subsections()
-                ]
-            )
+            for chap, sec, subsec in article.iter_subsections():
+                await self._supervisor_inner(article, article_outline, chap, sec, subsec)
+
         else:
             await gather(
                 *[
@@ -92,22 +97,29 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         from questionary import confirm, text
         from rich import print as r_print
 
-        ret = await self.search_database(article, article_outline, chap, sec, subsec)
-
-        cm = CitationManager(article_chunks=await ask_retain([r.chunk for r in ret], ret)).set_cite_number_all()
+        cm = CitationManager()
+        await self.search_database(article, article_outline, chap, sec, subsec, cm)
 
         raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm)
         r_print(raw)
 
         while not await confirm("Accept this version and continue?").ask_async():
-            if await confirm("Search for more refs?").ask_async():
-                new_refs = await self.search_database(article, article_outline, chap, sec, subsec, supervisor=True)
-                cm.add_chunks(await ask_retain([r.chunk for r in new_refs], new_refs))
+            if inst := await text("Search for more refs for additional spec.").ask_async():
+                await self.search_database(
+                    article,
+                    article_outline,
+                    chap,
+                    sec,
+                    subsec,
+                    cm,
+                    supervisor=True,
+                    extra_instruction=inst,
+                )
 
-            instruction = await text("Enter the instructions to improve").ask_async()
-            raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm, instruction)
-            if await confirm("Edit it?").ask_async():
-                raw = await text("Edit", default=raw).ask_async() or raw
+            if instruction := await text("Enter the instructions to improve").ask_async():
+                raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm, instruction)
+            if edt := await text("Edit", default=raw).ask_async():
+                raw = edt
 
             r_print(raw)
 
@@ -121,11 +133,14 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         sec: ArticleSection,
         subsec: ArticleSubsection,
     ) -> ArticleSubsection:
-        ret = await self.search_database(article, article_outline, chap, sec, subsec)
-        cm = CitationManager(article_chunks=ret).set_cite_number_all()
+        cm = CitationManager()
+
+        await self.search_database(article, article_outline, chap, sec, subsec, cm)
 
         raw_paras = await self.write_raw(article, article_outline, chap, sec, subsec, cm)
 
+        raw_paras = "\n".join(p for p in raw_paras.splitlines() if p and not p.endswith("**") and not p.startswith("#"))
+
         return await self.extract_new_subsec(subsec, raw_paras, cm)
 
     async def extract_new_subsec(
@@ -139,6 +154,7 @@ class WriteArticleContentRAG(Action, RAG, Extract):
                 f"Above is the subsection titled `{subsec.title}`.\n"
                 f"I need you to extract the content to update my subsection obj provided below.\n{self.req}"
                 f"{subsec.display()}\n",
+                model=self.extractor_model,
             ),
             "Failed to propose new subsection.",
         )
@@ -162,12 +178,15 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         return (
             (
                 await self.aask(
-                    f"{cm.as_prompt()}\nAbove is some related reference retrieved for you."
+                    f"{cm.as_prompt()}\nAbove is some related reference from other auther retrieved for you."
                     f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
                     f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
                     f"Please help me write the paragraphs of the subsec mentioned above, which is `{subsec.title}`.\n"
                     f"{self.req}\n"
-                    f"You SHALL use `{article.language}` as writing language.\n{extra_instruction}"
+                    f"You SHALL use `{article.language}` as writing language.\n{extra_instruction}\n"
+                    f"Do not use numbered list to display the outcome, you should regard you are writing the main text of the thesis.\n"
+                    f"You should not copy others' works from the references directly on to my thesis, we can only harness the conclusion they have drawn.\n"
+                    f"No extra explanation is allowed."
                 )
             )
             .replace(r" \( ", "$")
@@ -175,7 +194,9 @@ class WriteArticleContentRAG(Action, RAG, Extract):
             .replace(r"\(", "$")
             .replace(r"\)", "$")
             .replace("\\[\n", "$$\n")
+            .replace("\\[ ", "$$\n")
             .replace("\n\\]", "\n$$")
+            .replace(" \\]", "\n$$")
         )
 
     async def search_database(
@@ -185,28 +206,113 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         chap: ArticleChapter,
         sec: ArticleSection,
         subsec: ArticleSubsection,
+        cm: CitationManager,
         extra_instruction: str = "",
         supervisor: bool = False,
-    ) -> List[ArticleChunk]:
+    ) -> None:
         """Search database for related references."""
+        search_req = (
+            f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
+            f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
+            f"I need to search related references to build up the content of the subsec mentioned above, which is `{subsec.title}`.\n"
+            f"provide 10~16 queries as possible, to get best result!\n"
+            f"You should provide both English version and chinese version of the refined queries!\n{extra_instruction}\n"
+        )
+
         ref_q = ok(
             await self.arefined_query(
-                f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
-                f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
-                f"I need to search related references to build up the content of the subsec mentioned above, which is `{subsec.title}`.\n"
-                f"provide 10~16 queries as possible, to get best result!\n"
-                f"You should provide both English version and chinese version of the refined queries!\n{extra_instruction}\n",
+                search_req,
                 model=self.query_model,
             ),
             "Failed to refine query.",
         )
 
+        if supervisor:
+            ref_q = await ask_retain(ref_q)
+        ret = await self.aretrieve(
+            ref_q,
+            ArticleChunk,
+            final_limit=self.ref_limit,
+            result_per_query=self.result_per_query,
+            similarity_threshold=self.threshold,
+        )
+
+        cm.add_chunks(ok(ret))
+        ref_q = await self.arefined_query(
+            f"{cm.as_prompt()}\n\nAbove is the retrieved references in the first RAG, now we need to perform the second RAG.\n\n{search_req}",
+            model=self.query_model,
+        )
+
+        if ref_q is None:
+            logger.warning("Second refine query is None, skipping.")
+            return
         if supervisor:
             ref_q = await ask_retain(ref_q)
 
-        return await self.aretrieve(
-            ref_q, ArticleChunk, final_limit=self.ref_limit, result_per_query=3, similarity_threshold=self.threshold
+        ret = await self.aretrieve(
+            ref_q,
+            ArticleChunk,
+            final_limit=int(self.ref_limit * self.search_increment_multiplier),
+            result_per_query=int(self.result_per_query * self.search_increment_multiplier),
+            similarity_threshold=self.threshold,
         )
+        if ret is None:
+            logger.warning("Second retrieve is None, skipping.")
+            return
+        cm.add_chunks(ret)
+
+
+class ArticleConsultRAG(Action, RAG):
+    """Write an article based on the provided outline."""
+
+    output_key: str = "consult_count"
+
+    ref_limit: int = 20
+    """The final limit of references."""
+    ref_per_q: int = 3
+    """The limit of references to retrieve per query."""
+    similarity_threshold: float = 0.62
+    """The similarity threshold of references to retrieve."""
+    ref_q_model: Optional[str] = None
+    """The model to use for refining query."""
+    req: str = TYPST_CITE_USAGE
+    """The request for the rag model."""
+
+    @precheck_package(
+        "questionary", "`questionary` is required for supervisor mode, please install it by `fabricatio[qa]`"
+    )
+    async def _execute(self, collection_name: Optional[str] = None, **cxt) -> int:
+        from questionary import confirm, text
+        from rich import print as r_print
+
+        from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex
+
+        self.target_collection = collection_name or self.safe_target_collection
+
+        cm = CitationManager()
+
+        counter = 0
+        while (req := await text("User: ").ask_async()) is not None:
+            if await confirm("Empty the cm?").ask_async():
+                cm.empty()
+            ref_q = await self.arefined_query(req, model=self.ref_q_model)
+            refs = await self.aretrieve(
+                ok(ref_q, "Failed to refine query."),
+                ArticleChunk,
+                final_limit=self.ref_limit,
+                result_per_query=self.ref_per_q,
+                similarity_threshold=self.similarity_threshold,
+            )
+
+            ret = await self.aask(f"{cm.add_chunks(refs).as_prompt()}\n{self.req}\n{req}")
+            ret = convert_all_inline_tex(ret)
+            ret = convert_all_block_tex(ret)
+            ret = cm.apply(ret)
+
+            r_print(ret)
+            counter += 1
+        logger.info(f"{counter} rounds of conversation.")
+        return counter
 
 
 class TweakArticleRAG(Action, RAG, Censor):

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev1}/python/fabricatio/actions/output.py

@@ -1,16 +1,18 @@
 """Dump the finalized output to a file."""
 
 from pathlib import Path
-from typing import Any, Iterable, List, Mapping, Optional, Type
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Type
 
+from fabricatio import TEMPLATE_MANAGER
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.generic import FinalizedDumpAble, FromMapping, PersistentAble
 from fabricatio.models.task import Task
+from fabricatio.models.usages import LLMUsage
 from fabricatio.utils import ok
 
 
-class DumpFinalizedOutput(Action):
+class DumpFinalizedOutput(Action, LLMUsage):
     """Dump the finalized output to a file."""
 
     output_key: str = "dump_path"
@@ -38,7 +40,37 @@ class DumpFinalizedOutput(Action):
         return dump_path.as_posix()
 
 
-class PersistentAll(Action):
+class RenderedDump(Action, LLMUsage):
+    """Render the data to a file."""
+
+    output_key: str = "dump_path"
+    dump_path: Optional[str] = None
+
+    template_name: str
+    """The template name to render the data."""
+
+    async def _execute(
+        self,
+        to_dump: Dict[str, Any],
+        task_input: Optional[Task] = None,
+        dump_path: Optional[str | Path] = None,
+        **_,
+    ) -> str:
+        dump_path = Path(
+            dump_path
+            or self.dump_path
+            or ok(
+                await self.awhich_pathstr(
+                    f"{ok(task_input, 'Neither `task_input` and `dump_path` is provided.').briefing}\n\nExtract a single path of the file, to which I will dump the data."
+                ),
+                "Could not find the path of file to dump the data.",
+            )
+        )
+        logger.info(f"Saving output to {dump_path.as_posix()}")
+        return TEMPLATE_MANAGER.render_template(self.template_name, to_dump)
+
+
+class PersistentAll(Action, LLMUsage):
     """Persist all the data to a file."""
 
     output_key: str = "persistent_count"

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

@@ -328,9 +328,9 @@ class RoutingConfig(BaseModel):
     allowed_fails: Optional[int] = 3
     """The number of allowed fails before the routing is considered failed."""
     retry_after: int = 15
-    """The time in seconds to wait before retrying the routing after a fail."""
-    cooldown_time: Optional[int] = 30
-    """The time in seconds to wait before retrying the routing after a cooldown."""
+    """Minimum time to wait before retrying a failed request."""
+    cooldown_time: Optional[int] = 60
+    """Time to cooldown a deployment after failure in seconds."""
 
 
 class Settings(BaseSettings):

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev1}/python/fabricatio/fs/curd.py

@@ -20,7 +20,7 @@ def dump_text(path: Union[str, Path], text: str) -> None:
     Returns:
         None
     """
-    Path(path).write_text(text, encoding="utf-8", errors="ignore")
+    Path(path).write_text(text, encoding="utf-8", errors="ignore", newline="\n")
 
 
 def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev1}/python/fabricatio/models/action.py

@@ -12,12 +12,12 @@ Classes:
 import traceback
 from abc import abstractmethod
 from asyncio import Queue, create_task
-from typing import Any, Dict, Self, Tuple, Type, Union, final
+from typing import Any, Dict, Self, Sequence, Tuple, Type, Union, final
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
-from fabricatio.models.usages import LLMUsage, ToolBoxUsage
+from fabricatio.models.usages import ToolBoxUsage
 from fabricatio.utils import override_kwargs
 from pydantic import Field, PrivateAttr
 
@@ -26,7 +26,7 @@ OUTPUT_KEY = "task_output"
 INPUT_KEY = "task_input"
 
 
-class Action(WithBriefing, LLMUsage):
+class Action(WithBriefing):
     """Class that represents an action to be executed in a workflow.
 
     Actions are the atomic units of work in a workflow. Each action performs
@@ -96,9 +96,9 @@ class Action(WithBriefing, LLMUsage):
             return f"## Your personality: \n{self.personality}\n# The action you are going to perform: \n{super().briefing}"
         return f"# The action you are going to perform: \n{super().briefing}"
 
-    def to_task_output(self) -> Self:
+    def to_task_output(self, task_output_key: str = OUTPUT_KEY) -> Self:
         """Set the output key to OUTPUT_KEY and return the action instance."""
-        self.output_key = OUTPUT_KEY
+        self.output_key = task_output_key
         return self
 
 
@@ -123,9 +123,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """Instantiated action objects to be executed in this workflow."""
 
-    steps: Tuple[Union[Type[Action], Action], ...] = Field(
-        frozen=True,
-    )
+    steps: Sequence[Union[Type[Action], Action]] = Field(frozen=True)
     """The sequence of actions to be executed, can be action classes or instances."""
 
     task_input_key: str = Field(default=INPUT_KEY)