fabricatio 0.3.13__cp312-cp312-manylinux_2_34_x86_64.whl → 0.3.14__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/__init__.py

@@ -1,36 +1,29 @@
 """Fabricatio is a Python library for building llm app using event-based agent structure."""
 
-from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, BibManager, Event
-
-from fabricatio import actions, capabilities, toolboxes, workflows
-from fabricatio.core import env
+from fabricatio import actions, capabilities, fs, models, parser, toolboxes, utils, workflows
 from fabricatio.journal import logger
-from fabricatio.models import extra
 from fabricatio.models.action import Action, WorkFlow
 from fabricatio.models.role import Role
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
-from fabricatio.parser import Capture, GenericCapture, JsonCapture, PythonCapture
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, Event
 
 __all__ = [
     "CONFIG",
     "TEMPLATE_MANAGER",
     "Action",
-    "BibManager",
-    "Capture",
     "Event",
-    "GenericCapture",
-    "JsonCapture",
-    "PythonCapture",
     "Role",
     "Task",
     "ToolBox",
     "WorkFlow",
     "actions",
     "capabilities",
-    "env",
-    "extra",
+    "fs",
     "logger",
+    "models",
+    "parser",
     "toolboxes",
+    "utils",
     "workflows",
 ]

fabricatio/actions/article.py

@@ -2,9 +2,8 @@
 
 from asyncio import gather
 from pathlib import Path
-from typing import Callable, List, Optional
+from typing import Callable, ClassVar, List, Optional
 
-from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, BibManager, detect_language
 from more_itertools import filter_map
 from pydantic import Field
 from rich import print as r_print
@@ -16,13 +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.utils import ok, wrapp_in_block
 
 
@@ -38,10 +38,10 @@ class ExtractArticleEssence(Action, Propose):
     """The key of the output data."""
 
     async def _execute(
-            self,
-            task_input: Task,
-            reader: Callable[[str], Optional[str]] = lambda p: Path(p).read_text(encoding="utf-8"),
-            **_,
+        self,
+        task_input: Task,
+        reader: Callable[[str], Optional[str]] = lambda p: Path(p).read_text(encoding="utf-8"),
+        **_,
     ) -> List[ArticleEssence]:
         if not task_input.dependencies:
             logger.info(err := "Task not approved, since no dependencies are provided.")
@@ -54,11 +54,11 @@ class ExtractArticleEssence(Action, Propose):
         out = []
 
         for ess in await self.propose(
-                ArticleEssence,
-                [
-                    f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it.\n\nWrite the value string using `{detect_language(c)}`"
-                    for c in contents
-                ],
+            ArticleEssence,
+            [
+                f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it.\n\nWrite the value string using `{detect_language(c)}`"
+                for c in contents
+            ],
         ):
             if ess is None:
                 logger.warning("Could not extract article essence")
@@ -75,10 +75,10 @@ class FixArticleEssence(Action):
     """The key of the output data."""
 
     async def _execute(
-            self,
-            bib_mgr: BibManager,
-            article_essence: List[ArticleEssence],
-            **_,
+        self,
+        bib_mgr: BibManager,
+        article_essence: List[ArticleEssence],
+        **_,
     ) -> List[ArticleEssence]:
         out = []
         count = 0
@@ -105,11 +105,11 @@ class GenerateArticleProposal(Action, Propose):
     """The key of the output data."""
 
     async def _execute(
-            self,
-            task_input: Optional[Task] = None,
-            article_briefing: Optional[str] = None,
-            article_briefing_path: Optional[str] = None,
-            **_,
+        self,
+        task_input: Optional[Task] = None,
+        article_briefing: Optional[str] = None,
+        article_briefing_path: Optional[str] = None,
+        **_,
     ) -> Optional[ArticleProposal]:
         if article_briefing is None and article_briefing_path is None and task_input is None:
             logger.error("Task not approved, since all inputs are None.")
@@ -148,10 +148,10 @@ class GenerateInitialOutline(Action, Extract):
     """The kwargs to extract the outline."""
 
     async def _execute(
-            self,
-            article_proposal: ArticleProposal,
-            supervisor: Optional[bool] = None,
-            **_,
+        self,
+        article_proposal: ArticleProposal,
+        supervisor: Optional[bool] = None,
+        **_,
     ) -> Optional[ArticleOutline]:
         req = (
             f"Design each chapter of a proper and academic and ready for release manner.\n"
@@ -206,10 +206,10 @@ class FixIntrospectedErrors(Action, Censor):
     """The maximum number of errors to fix."""
 
     async def _execute(
-            self,
-            article_outline: ArticleOutline,
-            intro_fix_ruleset: Optional[RuleSet] = None,
-            **_,
+        self,
+        article_outline: ArticleOutline,
+        intro_fix_ruleset: Optional[RuleSet] = None,
+        **_,
     ) -> Optional[ArticleOutline]:
         counter = 0
         origin = article_outline
@@ -241,10 +241,10 @@ class GenerateArticle(Action, Censor):
     ruleset: Optional[RuleSet] = None
 
     async def _execute(
-            self,
-            article_outline: ArticleOutline,
-            article_gen_ruleset: Optional[RuleSet] = None,
-            **_,
+        self,
+        article_outline: ArticleOutline,
+        article_gen_ruleset: Optional[RuleSet] = None,
+        **_,
     ) -> Optional[Article]:
         article: Article = Article.from_outline(ok(article_outline, "Article outline not specified.")).update_ref(
             article_outline
@@ -277,43 +277,80 @@ 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
 
-    summary_word_count: int = 200
-
+    summary_word_count: int = 120
+    output_key: str = "summarized_article"
     summary_title: str = "Chapter Summary"
-    write_to: Optional[Path] = None
 
-    async def _execute(self, article: Article, write_to: Optional[Path] = None, **cxt) -> List[str]:
-        logger.info(";".join(a.title for a in article.chapters))
+    skip_chapters: List[str] = Field(default_factory=list)
+
+    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
+
+        # 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:
+            logger.warning(
+                "All chapters considered for summary were skipped as they lack sections. No summaries will be generated for these."
+            )
+
+        # 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:
+                c.sections.pop()
+
+            c.sections[-1].subsections.append(n)
 
-        return ret
+        article.update_article_file(article_path)
+
+        article_string = safe_text_read(article_path)
+        article_string.replace(f"=== {self.summary_title}", f"== {self.summary_title}")
+        dump_text(article_path, article_string)
+        return article

fabricatio/actions/article_rag.py

@@ -4,14 +4,6 @@ from asyncio import gather
 from pathlib import Path
 from typing import ClassVar, List, Optional
 
-from fabricatio.rust import (
-    BibManager,
-    convert_all_block_tex,
-    convert_all_inline_tex,
-    convert_to_block_formula,
-    convert_to_inline_formula,
-    fix_misplaced_labels,
-)
 from pydantic import Field, PositiveInt
 
 from fabricatio.capabilities.advanced_rag import AdvancedRAG
@@ -27,6 +19,11 @@ from fabricatio.models.extra.article_main import Article, ArticleChapter, Articl
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.kwargs_types import ChooseKwargs, LLMKwargs
+from fabricatio.rust import (
+    BibManager,
+    convert_all_tex_math,
+    fix_misplaced_labels,
+)
 from fabricatio.utils import ok
 
 TYPST_CITE_USAGE = (
@@ -78,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
@@ -103,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
@@ -129,20 +126,19 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
                 raw_paras = edt
 
             raw_paras = fix_misplaced_labels(raw_paras)
-            raw_paras = convert_all_inline_tex(raw_paras)
-            raw_paras = convert_all_block_tex(raw_paras)
+            raw_paras = convert_all_tex_math(raw_paras)
 
             r_print(raw_paras)
 
         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()
 
@@ -153,13 +149,12 @@ class WriteArticleContentRAG(Action, Extract, AdvancedRAG):
         raw_paras = "\n".join(p for p in raw_paras.splitlines() if p and not p.endswith("**") and not p.startswith("#"))
 
         raw_paras = fix_misplaced_labels(raw_paras)
-        raw_paras = convert_all_inline_tex(raw_paras)
-        raw_paras = convert_all_block_tex(raw_paras)
+        raw_paras = convert_all_tex_math(raw_paras)
 
         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(
@@ -182,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(
@@ -205,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 = (
@@ -261,8 +256,6 @@ class ArticleConsultRAG(Action, AdvancedRAG):
         from questionary import confirm, text
         from rich import print as r_print
 
-        from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex, fix_misplaced_labels
-
         self.target_collection = collection_name or self.safe_target_collection
 
         cm = CitationManager()
@@ -272,8 +265,7 @@ class ArticleConsultRAG(Action, AdvancedRAG):
             if await confirm("Empty the cm?").ask_async():
                 cm.empty()
 
-            req = convert_to_block_formula(req)
-            req = convert_to_inline_formula(req)
+            req = convert_all_tex_math(req)
 
             await self.clued_search(
                 req,
@@ -289,8 +281,7 @@ class ArticleConsultRAG(Action, AdvancedRAG):
             ret = await self.aask(f"{cm.as_prompt()}\n{self.req}\n{req}")
 
             ret = fix_misplaced_labels(ret)
-            ret = convert_all_inline_tex(ret)
-            ret = convert_all_block_tex(ret)
+            ret = convert_all_tex_math(ret)
             ret = cm.apply(ret)
 
             r_print(ret)
@@ -321,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.
 
@@ -381,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",
         )
 
 
@@ -399,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/actions/output.py

@@ -1,16 +1,16 @@
 """Dump the finalized output to a file."""
 
 from pathlib import Path
-from typing import Any, Iterable, List, Mapping, Optional, Type
-
-from fabricatio.rust import TEMPLATE_MANAGER
+from typing import Any, Iterable, List, Mapping, Optional, Self, Sequence, Type
 
+from fabricatio.capabilities.persist import PersistentAble
 from fabricatio.fs import dump_text
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.generic import FinalizedDumpAble, FromMapping, PersistentAble
+from fabricatio.models.generic import FinalizedDumpAble, FromMapping, FromSequence
 from fabricatio.models.task import Task
 from fabricatio.models.usages import LLMUsage
+from fabricatio.rust import TEMPLATE_MANAGER
 from fabricatio.utils import ok
 
 
@@ -21,11 +21,11 @@ class DumpFinalizedOutput(Action, LLMUsage):
     dump_path: Optional[str] = None
 
     async def _execute(
-            self,
-            to_dump: FinalizedDumpAble,
-            task_input: Optional[Task] = None,
-            dump_path: Optional[str | Path] = None,
-            **_,
+        self,
+        to_dump: FinalizedDumpAble,
+        task_input: Optional[Task] = None,
+        dump_path: Optional[str | Path] = None,
+        **_,
     ) -> str:
         dump_path = Path(
             dump_path
@@ -52,11 +52,11 @@ class RenderedDump(Action, LLMUsage):
     """The template name to render the data."""
 
     async def _execute(
-            self,
-            to_dump: FinalizedDumpAble,
-            task_input: Optional[Task] = None,
-            dump_path: Optional[str | Path] = None,
-            **_,
+        self,
+        to_dump: FinalizedDumpAble,
+        task_input: Optional[Task] = None,
+        dump_path: Optional[str | Path] = None,
+        **_,
     ) -> str:
         dump_path = Path(
             dump_path
@@ -91,10 +91,10 @@ class PersistentAll(Action, LLMUsage):
     """Whether to remove the existing dir before dumping."""
 
     async def _execute(
-            self,
-            task_input: Optional[Task] = None,
-            persist_dir: Optional[str | Path] = None,
-            **cxt,
+        self,
+        task_input: Optional[Task] = None,
+        persist_dir: Optional[str | Path] = None,
+        **cxt,
     ) -> int:
         persist_dir = Path(
             persist_dir
@@ -124,7 +124,7 @@ class PersistentAll(Action, LLMUsage):
                 v.persist(final_dir)
                 count += 1
             if isinstance(v, Iterable) and any(
-                    persistent_ables := (pers for pers in v if isinstance(pers, PersistentAble))
+                persistent_ables := (pers for pers in v if isinstance(pers, PersistentAble))
             ):
                 logger.info(f"Persisting collection {k} to {final_dir}")
                 final_dir.mkdir(parents=True, exist_ok=True)
@@ -174,11 +174,11 @@ class RetrieveFromLatest[T: PersistentAble](RetrieveFromPersistent[T], FromMappi
 
     @classmethod
     def from_mapping(
-            cls,
-            mapping: Mapping[str, str | Path],
-            *,
-            retrieve_cls: Type[T],
-            **kwargs,
+        cls,
+        mapping: Mapping[str, str | Path],
+        *,
+        retrieve_cls: Type[T],
+        **kwargs,
     ) -> List["RetrieveFromLatest[T]"]:
         """Create a list of `RetrieveFromLatest` from the mapping."""
         return [
@@ -212,3 +212,37 @@ class GatherAsList(Action):
         result = [cxt[k] for k in cxt if k.startswith(self.gather_prefix)]
         logger.debug(f"Gathered {len(result)} items with prefix {self.gather_prefix}")
         return result
+
+
+class Forward(Action, FromMapping, FromSequence):
+    """Forward the object from the context to the output."""
+
+    output_key: str = "forwarded"
+    """Gather the objects from the context as a list."""
+    original: str
+
+    async def _execute(self, *_: Any, **cxt) -> Any:
+        source = cxt.get(self.original)
+        if source is None:
+            logger.warning(f"Original object {self.original} not found in the context")
+        return source
+
+    @classmethod
+    def from_sequence(cls, sequence: Sequence[str], *, original: str, **kwargs: Any) -> List[Self]:
+        """Create a list of `Forward` from the sequence."""
+        return [cls(original=original, output_key=o, **kwargs) for o in sequence]
+
+    @classmethod
+    def from_mapping(cls, mapping: Mapping[str, str | Sequence[str]], **kwargs: Any) -> List[Self]:
+        """Create a list of `Forward` from the mapping."""
+        actions = []
+        for original_key, output_val in mapping.items():
+            if isinstance(output_val, str):
+                actions.append(cls(original=original_key, output_key=output_val, **kwargs))
+            elif isinstance(output_val, Sequence):
+                actions.extend(cls(original=original_key, output_key=output_key, **kwargs) for output_key in output_val)
+            else:
+                logger.warning(
+                    f"Invalid type for output key value in mapping: {type(output_val)} for original key {original_key}. Expected str or Sequence[str]."
+                )
+        return actions

fabricatio/actions/rag.py

@@ -2,13 +2,12 @@
 
 from typing import List, Optional
 
-from fabricatio.rust import CONFIG
-
 from fabricatio.capabilities.rag import RAG
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra.rag import MilvusClassicModel, MilvusDataBase
 from fabricatio.models.task import Task
+from fabricatio.rust import CONFIG
 from fabricatio.utils import ok
 
 
@@ -20,7 +19,7 @@ class InjectToDB(Action, RAG):
     """The name of the collection to inject data into."""
 
     async def _execute[T: MilvusDataBase](
-            self, to_inject: Optional[T] | List[Optional[T]], override_inject: bool = False, **_
+        self, to_inject: Optional[T] | List[Optional[T]], override_inject: bool = False, **_
     ) -> Optional[str]:
         from pymilvus.milvus_client import IndexParams