fabricatio 0.3.14.dev7__tar.gz → 0.3.15.dev4__tar.gz

fabricatio-0.3.15.dev4/.github/workflows/build-package.yaml

@@ -0,0 +1,130 @@
+name: Build and Release
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  determine_changes:
+    name: Determine Release Necessity & Version Details
+    runs-on: ubuntu-latest
+    outputs:
+      version_changed: ${{ steps.check_version_change.outputs.VERSION_CHANGED }}
+      current_version: ${{ steps.get_version.outputs.CURRENT_VERSION }}
+      is_prerelease: ${{ steps.check_prerelease.outputs.IS_PRERELEASE }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Get current version from pyproject.toml
+        id: get_version
+        run: |
+          CURRENT_VERSION_RAW=$(grep '^version' pyproject.toml | cut -d '"' -f 2)
+          echo "CURRENT_VERSION=v$CURRENT_VERSION_RAW" >> $GITHUB_OUTPUT
+        shell: bash
+      - name: Get latest git tag
+        uses: JinoArch/get-latest-tag@latest
+        id: tag
+      - name: Check if version has changed against latest tag
+        id: check_version_change
+        run: |
+          LATEST_TAG=${{ steps.tag.outputs.latestTag }}
+          VERSION_FROM_PYPROJECT=${{ steps.get_version.outputs.CURRENT_VERSION }}
+          echo "Latest git tag is $LATEST_TAG"
+          echo "Current version (from pyproject.toml, prefixed with 'v') is $VERSION_FROM_PYPROJECT"
+          if [ "$LATEST_TAG" != "$VERSION_FROM_PYPROJECT" ]; then
+              echo "VERSION_CHANGED=true" >> $GITHUB_OUTPUT
+            else
+              echo "VERSION_CHANGED=false" >> $GITHUB_OUTPUT
+          fi
+        shell: bash
+      - name: Check if current version is a prerelease
+        id: check_prerelease
+        run: |
+          VERSION_FROM_PYPROJECT=${{ steps.get_version.outputs.CURRENT_VERSION }}
+          if [[ "$VERSION_FROM_PYPROJECT" == *"-"* ]]; then # e.g., v1.0.0-alpha
+            echo "IS_PRERELEASE=true" >> $GITHUB_OUTPUT
+          else
+            echo "IS_PRERELEASE=false" >> $GITHUB_OUTPUT
+          fi
+        shell: bash
+
+
+  create-release:
+    if: needs.determine_changes.outputs.version_changed == 'true'
+    name: Create Release
+    needs: determine_changes
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Packing templates
+        run: |
+          tar -czf templates.tar.gz templates
+      - name: Create Release and upload assets
+        id: create_release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.determine_changes.outputs.current_version }}
+          name: ${{ needs.determine_changes.outputs.current_version }}
+          files: |
+            templates.tar.gz
+          prerelease: ${{ needs.determine_changes.outputs.is_prerelease }}
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+
+
+
+  check-and-release:
+    name: Build, Package, and Release
+    needs:
+      - create-release
+      - determine_changes
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ windows-latest, ubuntu-latest ]
+        python-version: [ "3.12", "3.13" ]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v6.0.1
+        with:
+          version: "latest"
+      - name: Install nightly rust
+        run: |
+          rustup default nightly
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v3
+
+      - name: Install deps
+        run: |
+          uv sync --no-install-project  --all-extras --index https://pypi.org/simple -p ${{ matrix.python-version }} 
+
+      - name: Build
+        run: |
+          make PY=${{ matrix.python-version }}
+
+      - name: Upload assets
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.determine_changes.outputs.current_version }}
+          files: |
+            dist/*.whl
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+
+      - name: Upload to PyPI
+        if: needs.determine_changes.outputs.version_changed == 'true'
+        run: |
+          make publish PY=${{ matrix.python-version }}
+        env:
+          MATURIN_USERNAME: __token__
+          MATURIN_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+

{fabricatio-0.3.14.dev7 → fabricatio-0.3.15.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.3.14.dev7
+Version: 0.3.15.dev4
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -185,4 +185,5 @@ Special thanks to the contributors and maintainers of:
 - [PyO3](https://github.com/PyO3/pyo3)
 - [Maturin](https://github.com/PyO3/maturin)
 - [Handlebars.rs](https://github.com/sunng87/handlebars-rust)
+- [LiteLLM](https://github.com/BerriAI/litellm)
 

{fabricatio-0.3.14.dev7 → fabricatio-0.3.15.dev4}/README.md

@@ -145,3 +145,4 @@ Special thanks to the contributors and maintainers of:
 - [PyO3](https://github.com/PyO3/pyo3)
 - [Maturin](https://github.com/PyO3/maturin)
 - [Handlebars.rs](https://github.com/sunng87/handlebars-rust)
+- [LiteLLM](https://github.com/BerriAI/litellm)

{fabricatio-0.3.14.dev7 → fabricatio-0.3.15.dev4}/examples/write_article/write_article.py

@@ -2,37 +2,43 @@
 
 import asyncio
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 
 import typer
-from fabricatio import Event, Role, WorkFlow, logger
+from fabricatio import Event, WorkFlow, logger
+from fabricatio import Role as RoleBase
 from fabricatio.actions.article import (
     ExtractOutlineFromRaw,
     GenerateArticleProposal,
     GenerateInitialOutline,
     WriteChapterSummary,
+    WriteResearchContentSummary,
 )
 from fabricatio.actions.article_rag import ArticleConsultRAG, WriteArticleContentRAG
 from fabricatio.actions.output import DumpFinalizedOutput, PersistentAll, RenderedDump
-from fabricatio.fs import safe_text_read
-from fabricatio.models.extra.article_main import Article
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.task import Task
+from fabricatio.models.usages import LLMUsage
 from fabricatio.utils import ok
 from typer import Typer
 
 # from pydantic import HttpUrl
 
+
+class Role(RoleBase, LLMUsage):
+    """Role class for article writing."""
+
+
 Role(
     name="Undergraduate Researcher",
     description="Write an outline for an article in typst format.",
-    llm_model="openai/qwen3-235b-a22b",
-    # llm_api_endpoint=HttpUrl("https://dashscope.aliyuncs.com/compatible-mode/v1"),
+    llm_model="openai/qwen-plus",
+    llm_api_endpoint="https://dashscope.aliyuncs.com/compatible-mode/v1",
     llm_stream=True,
     llm_max_tokens=8191,
     llm_rpm=600,
     llm_tpm=900000,
-    llm_timeout=600,
+    llm_timeout=10,
     registry={
         Event.quick_instantiate(ns := "article"): WorkFlow(
             name="Generate Article",
@@ -88,6 +94,11 @@ Role(
             description="Generate chapter summary based on given article outline. dump the outline to the given path. in typst format.",
             steps=(WriteChapterSummary().to_task_output(),),
         ),
+        Event.quick_instantiate(ns6 := "resc-suma"): WorkFlow(
+            name="Research Content Summary",
+            description="Generate research content summary based on given article outline. dump the outline to the given path. in typst format.",
+            steps=(WriteResearchContentSummary().to_task_output(),),
+        ),
     },
 )
 
@@ -209,21 +220,53 @@ def suma(
     article_path: Path = typer.Option(  # noqa: B008
         Path("article.typ"), "-a", "--article-path", help="Path to the article file."
     ),
-    dump_path: Path = typer.Option(Path("out.typ"), "-d", "--dump-path", help="Path to dump the final output."),  # noqa: B008
+    skip_chapters: List[str] = typer.Option(  # noqa: B008
+        [], "-s", "--skip-chapters", help="Chapters to skip."
+    ),
+    suma_title: str = typer.Option("Chapter Summary", "-t", "--suma-title", help="Title of the chapter summary."),
+    summary_word_count: int = typer.Option(220, "-w", "--word-count", help="Word count for the summary."),
 ) -> None:
     """Write chap summary based on given article."""
-    path = ok(
+    _ = ok(
         asyncio.run(
             Task(name="write an article")
             .update_init_context(
-                article=Article.from_typst_code("article", body=safe_text_read(article_path)),
-                write_to=dump_path,
+                article_path=article_path,
+                summary_title=suma_title,
+                skip_chapters=skip_chapters,
+                summary_word_count=summary_word_count,
             )
             .delegate(ns5)
         ),
         "Failed to generate an article ",
     )
-    logger.success(f"The outline is saved in:\n{path}")
+    logger.success(f"The outline is saved in:\n{article_path.as_posix()}")
+
+
+@app.command()
+def rcsuma(
+    article_path: Path = typer.Option(  # noqa: B008
+        Path("article.typ"), "-a", "--article-path", help="Path to the article file."
+    ),
+    suma_title: str = typer.Option("Research Content", "-t", "--suma-title", help="Title of the summary."),
+    summary_word_count: int = typer.Option(220, "-w", "--word-count", help="Word count for the summary."),
+    paragraph_count: int = typer.Option(1, "-p", "--paragraph-count", help="Number of paragraphs for the summary."),
+) -> None:
+    """Write research summary based on given article."""
+    _ = ok(
+        asyncio.run(
+            Task(name="write an article")
+            .update_init_context(
+                article_path=article_path,
+                summary_title=suma_title,
+                summary_word_count=summary_word_count,
+                paragraph_count=paragraph_count,
+            )
+            .delegate(ns6)
+        ),
+        "Failed to generate an article ",
+    )
+    logger.success(f"The outline is saved in:\n{article_path.as_posix()}")
 
 
 if __name__ == "__main__":

{fabricatio-0.3.14.dev7 → fabricatio-0.3.15.dev4}/pyproject.toml

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

{fabricatio-0.3.14.dev7 → fabricatio-0.3.15.dev4}/python/fabricatio/actions/article.py

@@ -2,7 +2,7 @@
 
 from asyncio import gather
 from pathlib import Path
-from typing import Callable, List, Optional
+from typing import Callable, ClassVar, List, Optional
 
 from more_itertools import filter_map
 from pydantic import Field
@@ -15,14 +15,14 @@ from fabricatio.fs import dump_text, safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra.article_essence import ArticleEssence
-from fabricatio.models.extra.article_main import Article
+from fabricatio.models.extra.article_main import Article, ArticleChapter, ArticleSubsection
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.usages import LLMUsage
-from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, BibManager, detect_language
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, BibManager, detect_language, word_count
 from fabricatio.utils import ok, wrapp_in_block
 
 
@@ -277,43 +277,139 @@ class LoadArticle(Action):
 class WriteChapterSummary(Action, LLMUsage):
     """Write the chapter summary."""
 
-    output_key: str = "chapter_summaries"
+    ctx_override: ClassVar[bool] = True
 
     paragraph_count: int = 1
+    """The number of paragraphs to generate in the chapter summary."""
 
-    summary_word_count: int = 200
-
+    summary_word_count: int = 120
+    """The number of words to use in each chapter summary."""
+    output_key: str = "summarized_article"
+    """The key under which the summarized article will be stored in the output."""
     summary_title: str = "Chapter Summary"
-    write_to: Optional[Path] = None
+    """The title to be used for the generated chapter summary section."""
+
+    skip_chapters: List[str] = Field(default_factory=list)
+    """A list of chapter titles to skip during summary generation."""
+
+    async def _execute(self, article_path: Path, **cxt) -> Article:
+        article = Article.from_article_file(article_path, article_path.stem)
+
+        chaps = [c for c in article.chapters if c.title not in self.skip_chapters]
+
+        retained_chapters = []
+        # Count chapters before filtering based on section presence,
+        # chaps at this point has already been filtered by self.skip_chapters
+        initial_chaps_for_summary_step_count = len(chaps)
+
+        for chapter_candidate in chaps:
+            if chapter_candidate.sections:  # Check if the sections list is non-empty
+                retained_chapters.append(chapter_candidate)
+            else:
+                # Log c warning for each chapter skipped due to lack of sections
+                logger.warning(
+                    f"Chapter '{chapter_candidate.title}' has no sections and will be skipped for summary generation."
+                )
+
+        chaps = retained_chapters  # Update chaps to only include chapters with sections
 
-    async def _execute(self, article: Article, write_to: Optional[Path] = None, **cxt) -> List[str]:
-        logger.info(";".join(a.title for a in article.chapters))
+        # If chaps is now empty, but there were chapters to consider at the start of this step,
+        # log c specific warning.
+        if not chaps and initial_chaps_for_summary_step_count > 0:
+            raise ValueError("No chapters with sections were found. Please check your input data.")
 
+        # This line was part of the original selection.
+        # It will now log the titles of the chapters that are actually being processed (those with sections).
+        # If 'chaps' is empty, this will result in logger.info(""), which is acceptable.
+        logger.info(";".join(a.title for a in chaps))
         ret = [
-            f"== {self.summary_title}\n{raw}"
+            ArticleSubsection.from_typst_code(self.summary_title, raw)
             for raw in (
                 await self.aask(
                     TEMPLATE_MANAGER.render_template(
                         CONFIG.templates.chap_summary_template,
                         [
                             {
-                                "chapter": a.to_typst_code(),
-                                "title": a.title,
-                                "language": a.language,
+                                "chapter": c.to_typst_code(),
+                                "title": c.title,
+                                "language": c.language,
                                 "summary_word_count": self.summary_word_count,
                                 "paragraph_count": self.paragraph_count,
                             }
-                            for a in article.chapters
+                            for c in chaps
                         ],
                     )
                 )
             )
         ]
 
-        if (to := (self.write_to or write_to)) is not None:
-            dump_text(
-                to,
-                "\n\n\n".join(f"//{a.title}\n\n{s}" for a, s in zip(article.chapters, ret, strict=True)),
+        for c, n in zip(chaps, ret, strict=True):
+            c: ArticleChapter
+            n: ArticleSubsection
+            if c.sections[-1].title == self.summary_title:
+                logger.debug(f"Removing old summary `{self.summary_title}` at {c.title}")
+                c.sections.pop()
+
+            c.sections[-1].subsections.append(n)
+
+        article.update_article_file(article_path)
+
+        dump_text(
+            article_path, safe_text_read(article_path).replace(f"=== {self.summary_title}", f"== {self.summary_title}")
+        )
+        return article
+
+
+class WriteResearchContentSummary(Action, LLMUsage):
+    """Write the research content summary."""
+
+    ctx_override: ClassVar[bool] = True
+    summary_word_count: int = 160
+    """The number of words to use in the research content summary."""
+
+    output_key: str = "summarized_article"
+    """The key under which the summarized article will be stored in the output."""
+
+    summary_title: str = "Research Content"
+    """The title to be used for the generated research content summary section."""
+
+    paragraph_count: int = 1
+    """The number of paragraphs to generate in the research content summary."""
+
+    async def _execute(self, article_path: Path, **cxt) -> Article:
+        article = Article.from_article_file(article_path, article_path.stem)
+        if not article.chapters:
+            raise ValueError("No chapters found in the article.")
+        chap_1 = article.chapters[0]
+        if not chap_1.sections:
+            raise ValueError("No sections found in the first chapter of the article.")
+
+        outline = article.extrac_outline()
+        suma: str = await self.aask(
+            TEMPLATE_MANAGER.render_template(
+                CONFIG.templates.research_content_summary_template,
+                {
+                    "title": outline.title,
+                    "outline": outline.to_typst_code(),
+                    "language": detect_language(self.summary_title),
+                    "summary_word_count": self.summary_word_count,
+                    "paragraph_count": self.paragraph_count,
+                },
             )
+        )
+        logger.success(
+            f"{self.summary_title}|Wordcount: {word_count(suma)}|Expected: {self.summary_word_count}\n{suma}"
+        )
+
+        if chap_1.sections[-1].title == self.summary_title:
+            # remove old
+            logger.debug(f"Removing old summary `{self.summary_title}`")
+            chap_1.sections.pop()
 
-        return ret
+        chap_1.sections[-1].subsections.append(ArticleSubsection.from_typst_code(self.summary_title, suma))
+
+        article.update_article_file(article_path)
+        dump_text(
+            article_path, safe_text_read(article_path).replace(f"=== {self.summary_title}", f"== {self.summary_title}")
+        )
+        return article

{fabricatio-0.3.14.dev7 → fabricatio-0.3.15.dev4}/python/fabricatio/actions/article_rag.py

@@ -1,11 +1,11 @@
 """A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
 
 from asyncio import gather
-
 from pathlib import Path
-from pydantic import Field, PositiveInt
 from typing import ClassVar, List, Optional
 
+from pydantic import Field, PositiveInt
+
 from fabricatio.capabilities.advanced_rag import AdvancedRAG
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.extract import Extract
@@ -75,11 +75,11 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
     tei_endpoint: Optional[str] = None
 
     async def _execute(
-            self,
-            article_outline: ArticleOutline,
-            collection_name: Optional[str] = None,
-            supervisor: Optional[bool] = None,
-            **cxt,
+        self,
+        article_outline: ArticleOutline,
+        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
@@ -100,12 +100,12 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         "questionary", "`questionary` is required for supervisor mode, please install it by `fabricatio[qa]`"
     )
     async def _supervisor_inner(
-            self,
-            article: Article,
-            article_outline: ArticleOutline,
-            chap: ArticleChapter,
-            sec: ArticleSection,
-            subsec: ArticleSubsection,
+        self,
+        article: Article,
+        article_outline: ArticleOutline,
+        chap: ArticleChapter,
+        sec: ArticleSection,
+        subsec: ArticleSubsection,
     ) -> ArticleSubsection:
         from questionary import confirm, text
         from rich import print as r_print
@@ -133,12 +133,12 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         return await self.extract_new_subsec(subsec, raw_paras, cm)
 
     async def _inner(
-            self,
-            article: Article,
-            article_outline: ArticleOutline,
-            chap: ArticleChapter,
-            sec: ArticleSection,
-            subsec: ArticleSubsection,
+        self,
+        article: Article,
+        article_outline: ArticleOutline,
+        chap: ArticleChapter,
+        sec: ArticleSection,
+        subsec: ArticleSubsection,
     ) -> ArticleSubsection:
         cm = CitationManager()
 
@@ -154,7 +154,7 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         return await self.extract_new_subsec(subsec, raw_paras, cm)
 
     async def extract_new_subsec(
-            self, subsec: ArticleSubsection, raw_paras: str, cm: CitationManager
+        self, subsec: ArticleSubsection, raw_paras: str, cm: CitationManager
     ) -> ArticleSubsection:
         """Extract the new subsec."""
         new_subsec = ok(
@@ -177,14 +177,14 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         return subsec
 
     async def write_raw(
-            self,
-            article: Article,
-            article_outline: ArticleOutline,
-            chap: ArticleChapter,
-            sec: ArticleSection,
-            subsec: ArticleSubsection,
-            cm: CitationManager,
-            extra_instruction: str = "",
+        self,
+        article: Article,
+        article_outline: ArticleOutline,
+        chap: ArticleChapter,
+        sec: ArticleSection,
+        subsec: ArticleSubsection,
+        cm: CitationManager,
+        extra_instruction: str = "",
     ) -> str:
         """Write the raw paragraphs of the subsec."""
         return await self.aask(
@@ -200,14 +200,14 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         )
 
     async def search_database(
-            self,
-            article: Article,
-            article_outline: ArticleOutline,
-            chap: ArticleChapter,
-            sec: ArticleSection,
-            subsec: ArticleSubsection,
-            cm: CitationManager,
-            extra_instruction: str = "",
+        self,
+        article: Article,
+        article_outline: ArticleOutline,
+        chap: ArticleChapter,
+        sec: ArticleSection,
+        subsec: ArticleSubsection,
+        cm: CitationManager,
+        extra_instruction: str = "",
     ) -> None:
         """Search database for related references."""
         search_req = (
@@ -312,12 +312,12 @@ class TweakArticleRAG(Action, RAG, Censor):
     """The limit of references to be retrieved"""
 
     async def _execute(
-            self,
-            article: Article,
-            collection_name: str = "article_essence",
-            twk_rag_ruleset: Optional[RuleSet] = None,
-            parallel: bool = False,
-            **cxt,
+        self,
+        article: Article,
+        collection_name: str = "article_essence",
+        twk_rag_ruleset: Optional[RuleSet] = None,
+        parallel: bool = False,
+        **cxt,
     ) -> Article:
         """Write an article based on the provided outline.
 
@@ -372,10 +372,10 @@ class TweakArticleRAG(Action, RAG, Censor):
             subsec,
             ruleset=ruleset,
             reference=f"{'\n\n'.join(d.display() for d in await self.aretrieve(refind_q, document_model=ArticleEssence, max_accepted=self.ref_limit))}\n\n"
-                      f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
-                      f"You should Always use `{subsec.language}` as written language, "
-                      f"which is the original language of the `{subsec.title}`. "
-                      f"since rewrite a `{subsec.__class__.__name__}` in a different language is usually a bad choice",
+            f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
+            f"You should Always use `{subsec.language}` as written language, "
+            f"which is the original language of the `{subsec.title}`. "
+            f"since rewrite a `{subsec.__class__.__name__}` in a different language is usually a bad choice",
         )
 
 
@@ -390,12 +390,12 @@ class ChunkArticle(Action):
     """The maximum overlapping rate between chunks."""
 
     async def _execute(
-            self,
-            article_path: str | Path,
-            bib_manager: BibManager,
-            max_chunk_size: Optional[int] = None,
-            max_overlapping_rate: Optional[float] = None,
-            **_,
+        self,
+        article_path: str | Path,
+        bib_manager: BibManager,
+        max_chunk_size: Optional[int] = None,
+        max_overlapping_rate: Optional[float] = None,
+        **_,
     ) -> List[ArticleChunk]:
         return ArticleChunk.from_file(
             article_path,

{fabricatio-0.3.14.dev7 → fabricatio-0.3.15.dev4}/python/fabricatio/decorators.py

@@ -235,6 +235,7 @@ def logging_exec_time[**P, R](
         @wraps(func)
         async def _async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             start_time = time()
+            logger.debug(f"Starting execution of {func.__name__}")
             result = await func(*args, **kwargs)
             logger.debug(f"Execution time of `{func.__name__}`: {time() - start_time:.2f} s")
             return result
@@ -244,6 +245,7 @@ def logging_exec_time[**P, R](
     @wraps(func)
     def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         start_time = time()
+        logger.debug(f"Starting execution of {func.__name__}")
         result = func(*args, **kwargs)
         logger.debug(f"Execution time of {func.__name__}: {(time() - start_time) * 1000:.2f} ms")
         return result