fabricatio 0.3.15.dev4__cp312-cp312-win_amd64.whl → 0.4.4__cp312-cp312-win_amd64.whl

fabricatio/actions/rag.py

@@ -1,96 +0,0 @@
-"""Inject data into the database."""
-
-from typing import List, Optional
-
-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
-
-
-class InjectToDB(Action, RAG):
-    """Inject data into the database."""
-
-    output_key: str = "collection_name"
-    collection_name: str = "my_collection"
-    """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, **_
-    ) -> Optional[str]:
-        from pymilvus.milvus_client import IndexParams
-
-        if to_inject is None:
-            return None
-        if not isinstance(to_inject, list):
-            to_inject = [to_inject]
-        if not (seq := [t for t in to_inject if t is not None]):  # filter out None
-            return None
-        logger.info(f"Injecting {len(seq)} items into the collection '{self.collection_name}'")
-        if override_inject:
-            self.check_client().client.drop_collection(self.collection_name)
-
-        await self.view(
-            self.collection_name,
-            create=True,
-            schema=seq[0].as_milvus_schema(
-                ok(
-                    self.milvus_dimensions
-                    or CONFIG.rag.milvus_dimensions
-                    or self.embedding_dimensions
-                    or CONFIG.embedding.dimensions
-                ),
-            ),
-            index_params=IndexParams(
-                seq[0].vector_field_name,
-                index_name=seq[0].vector_field_name,
-                index_type=seq[0].index_type,
-                metric_type=seq[0].metric_type,
-            ),
-        ).add_document(seq, flush=True)
-
-        return self.collection_name
-
-
-class RAGTalk(Action, RAG):
-    """RAG-enabled conversational action that processes user questions based on a given task.
-
-    This action establishes an interactive conversation loop where it retrieves context-relevant
-    information to answer user queries according to the assigned task briefing.
-
-    Notes:
-        task_input: Task briefing that guides how to respond to user questions
-        collection_name: Name of the vector collection to use for retrieval (default: "my_collection")
-
-    Returns:
-        Number of conversation turns completed before termination
-    """
-
-    output_key: str = "task_output"
-
-    async def _execute(self, task_input: Task[str], **kwargs) -> int:
-        from questionary import text
-
-        collection_name = kwargs.get("collection_name", "my_collection")
-        counter = 0
-
-        self.view(collection_name, create=True)
-
-        try:
-            while True:
-                user_say = await text("User: ").ask_async()
-                if user_say is None:
-                    break
-                ret: List[MilvusClassicModel] = await self.aretrieve(user_say, document_model=MilvusClassicModel)
-
-                gpt_say = await self.aask(
-                    user_say, system_message="\n".join(m.text for m in ret) + "\nYou can refer facts provided above."
-                )
-                print(f"GPT: {gpt_say}")  # noqa: T201
-                counter += 1
-        except KeyboardInterrupt:
-            logger.info(f"executed talk action {counter} times")
-        return counter

fabricatio/actions/rules.py

@@ -1,83 +0,0 @@
-"""A module containing the DraftRuleSet action."""
-
-from typing import Any, List, Mapping, Optional, Self, Tuple
-
-from fabricatio.capabilities.check import Check
-from fabricatio.journal import logger
-from fabricatio.models.action import Action
-from fabricatio.models.extra.rule import RuleSet
-from fabricatio.models.generic import FromMapping
-from fabricatio.utils import ok
-
-
-class DraftRuleSet(Action, Check, FromMapping):
-    """Action to draft a ruleset based on a given requirement description."""
-
-    output_key: str = "drafted_ruleset"
-    """The key used to store the drafted ruleset in the context dictionary."""
-
-    ruleset_requirement: Optional[str] = None
-    """The natural language description of the desired ruleset characteristics."""
-    rule_count: int = 0
-    """The number of rules to generate in the ruleset (0 for no restriction)."""
-
-    async def _execute(
-        self,
-        ruleset_requirement: Optional[str] = None,
-        **_,
-    ) -> Optional[RuleSet]:
-        """Draft a ruleset based on the requirement description.
-
-        Args:
-            ruleset_requirement (str): Natural language description of desired ruleset characteristics
-            rule_count (int): Number of rules to generate (0 for no restriction)
-            **kwargs: Validation parameters for rule generation
-
-        Returns:
-            Optional[RuleSet]: Drafted ruleset object or None if generation fails
-        """
-        ruleset = await self.draft_ruleset(
-            ruleset_requirement=ok(ruleset_requirement or self.ruleset_requirement, "No ruleset requirement provided"),
-            rule_count=self.rule_count,
-        )
-        if ruleset:
-            logger.info(f"Drafted Ruleset length: {len(ruleset.rules)}\n{ruleset.display()}")
-        else:
-            logger.warning(f"Drafting Rule Failed for:\n{ruleset_requirement}")
-        return ruleset
-
-    @classmethod
-    def from_mapping(cls, mapping: Mapping[str, Tuple[int, str]], **kwargs) -> List[Self]:
-        """Create a list of DraftRuleSet actions from a mapping of output keys to tuples of rule counts and requirements."""
-        return [cls(ruleset_requirement=r, rule_count=c, output_key=k, **kwargs) for k, (c, r) in mapping.items()]
-
-
-class GatherRuleset(Action, FromMapping):
-    """Action to gather a ruleset from a given requirement description."""
-
-    output_key: str = "gathered_ruleset"
-    """The key used to store the drafted ruleset in the context dictionary."""
-
-    to_gather: List[str]
-    """the cxt name of RuleSet to gather"""
-
-    @classmethod
-    def from_mapping(cls, mapping: Mapping[str, List[str]], **kwargs: Any) -> List[Self]:
-        """Create a list of GatherRuleset actions from a mapping of output keys to tuples of rule counts and requirements."""
-        return [cls(to_gather=t, output_key=k, **kwargs) for k, t in mapping.items()]
-
-    async def _execute(self, **cxt) -> RuleSet:
-        logger.info(f"Gathering Ruleset from {self.to_gather}")
-        # Fix for not_found
-        not_found = next((t for t in self.to_gather if t not in cxt), None)
-        if not_found:
-            raise ValueError(
-                f"Not all required keys found in context: {self.to_gather}|`{not_found}` not found in context."
-            )
-
-        # Fix for invalid RuleSet check
-        invalid = next((t for t in self.to_gather if not isinstance(cxt[t], RuleSet)), None)
-        if invalid is not None:
-            raise TypeError(f"Invalid RuleSet instance for key `{invalid}`")
-
-        return RuleSet.gather(*[cxt[t] for t in self.to_gather])

fabricatio/capabilities/advanced_judge.py

@@ -1,20 +0,0 @@
-"""The Capabilities module for advanced judging."""
-
-from abc import ABC
-from typing import Optional, Unpack
-
-from fabricatio.capabilities.propose import Propose
-from fabricatio.models.extra.advanced_judge import JudgeMent
-from fabricatio.models.kwargs_types import ValidateKwargs
-
-
-class AdvancedJudge(Propose, ABC):
-    """A class that judges the evidence and makes a final decision."""
-
-    async def evidently_judge(
-        self,
-        prompt: str,
-        **kwargs: Unpack[ValidateKwargs[JudgeMent]],
-    ) -> Optional[JudgeMent]:
-        """Judge the evidence and make a final decision."""
-        return await self.propose(JudgeMent, prompt, **kwargs)

fabricatio/capabilities/advanced_rag.py

@@ -1,61 +0,0 @@
-"""Advanced RAG (Retrieval Augmented Generation) model."""
-
-from abc import ABC
-from typing import Optional, Unpack
-
-from fabricatio.capabilities.rag import RAG
-from fabricatio.journal import logger
-from fabricatio.models.adv_kwargs_types import FetchKwargs
-from fabricatio.models.extra.aricle_rag import ArticleChunk, CitationManager
-from fabricatio.models.kwargs_types import ChooseKwargs
-from fabricatio.utils import fallback_kwargs
-
-
-class AdvancedRAG(RAG, ABC):
-    """A class representing the Advanced RAG (Retrieval Augmented Generation) model."""
-
-    async def clued_search(
-        self,
-        requirement: str,
-        cm: CitationManager,
-        max_capacity: int = 40,
-        max_round: int = 3,
-        expand_multiplier: float = 1.4,
-        base_accepted: int = 12,
-        refinery_kwargs: Optional[ChooseKwargs] = None,
-        **kwargs: Unpack[FetchKwargs],
-    ) -> CitationManager:
-        """Asynchronously performs a clued search based on a given requirement and citation manager."""
-        if max_round <= 0:
-            raise ValueError("max_round should be greater than 0")
-        if max_round == 1:
-            logger.warning(
-                "max_round should be greater than 1, otherwise it behaves nothing different from the `self.aretrieve`"
-            )
-
-        refinery_kwargs = refinery_kwargs or {}
-
-        for i in range(1, max_round + 1):
-            logger.info(f"Round [{i}/{max_round}] search started.")
-            ref_q = await self.arefined_query(
-                f"{cm.as_prompt()}\n\nAbove is the retrieved references in the {i - 1}th RAG, now we need to perform the {i}th RAG."
-                f"\n\n{requirement}",
-                **refinery_kwargs,
-            )
-
-            if ref_q is None:
-                logger.error(f"At round [{i}/{max_round}] search, failed to refine the query, exit.")
-                return cm
-            refs = await self.aretrieve(
-                ref_q, ArticleChunk, base_accepted, **fallback_kwargs(kwargs, filter_expr=cm.as_milvus_filter_expr())
-            )
-
-            if (max_capacity := max_capacity - len(refs)) < 0:
-                cm.add_chunks(refs[0:max_capacity])
-                logger.debug(f"At round [{i}/{max_round}] search, the capacity is not enough, exit.")
-                return cm
-
-            cm.add_chunks(refs)
-            base_accepted = int(base_accepted * expand_multiplier)
-        logger.debug(f"Exceeded max_round: {max_round}, exit.")
-        return cm

fabricatio/capabilities/censor.py

@@ -1,105 +0,0 @@
-"""Module for censoring objects and strings based on provided rulesets.
-
-This module includes the Censor class which inherits from both Correct and Check classes.
-It provides methods to censor objects and strings by first checking them against a ruleset and then correcting them if necessary.
-"""
-
-from abc import ABC
-from typing import Optional, Unpack
-
-from fabricatio.capabilities.check import Check
-from fabricatio.capabilities.correct import Correct
-from fabricatio.journal import logger
-from fabricatio.models.extra.problem import Improvement
-from fabricatio.models.extra.rule import RuleSet
-from fabricatio.models.generic import ProposedUpdateAble, SketchedAble
-from fabricatio.models.kwargs_types import ReferencedKwargs
-from fabricatio.utils import override_kwargs
-
-
-class Censor(Correct, Check, ABC):
-    """Class to censor objects and strings based on provided rulesets.
-
-    Inherits from both Correct and Check classes.
-    Provides methods to censor objects and strings by first checking them against a ruleset and then correcting them if necessary.
-
-    """
-
-    async def censor_obj[M: SketchedAble](
-        self, obj: M, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[M]]
-    ) -> Optional[M]:
-        """Censors an object based on the provided ruleset.
-
-        Args:
-            obj (M): The object to be censored.
-            ruleset (RuleSet): The ruleset to apply for censoring.
-            **kwargs: Additional keyword arguments to be passed to the check and correct methods.
-
-        Returns:
-            Optional[M]: The censored object if corrections were made, otherwise None.
-
-        Note:
-            This method first checks the object against the ruleset and then corrects it if necessary.
-        """
-        imp = await self.check_obj(obj, ruleset, **override_kwargs(kwargs, default=None))
-        if imp is None:
-            return None
-        if not imp:
-            logger.info(f"No improvement found for `{obj.__class__.__name__}`.")
-            return obj
-        logger.info(f"Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}")
-        return await self.correct_obj(obj, Improvement.gather(*imp), **kwargs)
-
-    async def censor_string(
-        self, input_text: str, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[str]]
-    ) -> Optional[str]:
-        """Censors a string based on the provided ruleset.
-
-        Args:
-            input_text (str): The string to be censored.
-            ruleset (RuleSet): The ruleset to apply for censoring.
-            **kwargs: Additional keyword arguments to be passed to the check and correct methods.
-
-        Returns:
-            Optional[str]: The censored string if corrections were made, otherwise None.
-
-        Note:
-            This method first checks the string against the ruleset and then corrects it if necessary.
-        """
-        imp = await self.check_string(input_text, ruleset, **override_kwargs(kwargs, default=None))
-        if imp is None:
-            logger.warning(f"Censor failed for string:\n{input_text}")
-            return None
-        if not imp:
-            logger.info("No improvement found for string.")
-            return input_text
-        logger.info(f"Generated {len(imp)} improvement(s) for string.")
-        return await self.correct_string(input_text, Improvement.gather(*imp), **kwargs)
-
-    async def censor_obj_inplace[M: ProposedUpdateAble](
-        self, obj: M, ruleset: RuleSet, **kwargs: Unpack[ReferencedKwargs[M]]
-    ) -> Optional[M]:
-        """Censors an object in-place based on the provided ruleset.
-
-        This method modifies the object directly if corrections are needed.
-
-        Args:
-            obj (M): The object to be censored.
-            ruleset (RuleSet): The ruleset to apply for censoring.
-            **kwargs: Additional keyword arguments to be passed to the check and correct methods.
-
-        Returns:
-            Optional[M]: The censored object if corrections were made, otherwise None.
-
-        Note:
-            This method first checks the object against the ruleset and then corrects it in-place if necessary.
-        """
-        imp = await self.check_obj(obj, ruleset, **override_kwargs(kwargs, default=None))
-        if imp is None:
-            logger.warning(f"Censor failed for `{obj.__class__.__name__}`")
-            return None
-        if not imp:
-            logger.info(f"No improvement found for `{obj.__class__.__name__}`.")
-            return obj
-        logger.info(f"Generated {len(imp)} improvement(s) for `{obj.__class__.__name__}")
-        return await self.correct_obj_inplace(obj, improvement=Improvement.gather(*imp), **kwargs)

fabricatio/capabilities/check.py

@@ -1,212 +0,0 @@
-"""A class that provides the capability to check strings and objects against rules and guidelines."""
-
-from abc import ABC
-from asyncio import gather
-from typing import List, Optional, Unpack
-
-from fabricatio.capabilities.advanced_judge import AdvancedJudge
-from fabricatio.capabilities.propose import Propose
-from fabricatio.journal import logger
-from fabricatio.models.extra.patches import RuleSetMetadata
-from fabricatio.models.extra.problem import Improvement
-from fabricatio.models.extra.rule import Rule, RuleSet
-from fabricatio.models.generic import Display, WithBriefing
-from fabricatio.models.kwargs_types import ValidateKwargs
-from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, detect_language
-from fabricatio.utils import override_kwargs
-
-
-class Check(AdvancedJudge, Propose, ABC):
-    """Class for validating strings/objects against predefined rules and guidelines.
-
-    This capability combines rule-based judgment and proposal generation to provide
-    structured validation results with actionable improvement suggestions.
-    """
-
-    async def draft_ruleset(
-        self, ruleset_requirement: str, rule_count: int = 0, **kwargs: Unpack[ValidateKwargs[Rule]]
-    ) -> Optional[RuleSet]:
-        """Generate rule set based on requirement description.
-
-        Args:
-            ruleset_requirement (str): Natural language description of desired ruleset characteristics
-            rule_count (int): Number of rules to generate (0 for default count)
-            **kwargs: Validation parameters for rule generation
-
-        Returns:
-            Optional[RuleSet]: Validated ruleset object or None if generation fails
-
-        Notes:
-            - Requires valid template configuration in configs.templates
-            - Returns None if any step in rule generation fails
-            - Uses `alist_str` for requirement breakdown and iterative rule proposal
-        """
-        rule_reqs = (
-            await self.alist_str(
-                TEMPLATE_MANAGER.render_template(
-                    CONFIG.templates.ruleset_requirement_breakdown_template,
-                    {"ruleset_requirement": ruleset_requirement},
-                ),
-                rule_count,
-                **override_kwargs(kwargs, default=None),
-            )
-            if rule_count > 1
-            else [ruleset_requirement]
-        )
-
-        if rule_reqs is None:
-            return None
-
-        rules = await self.propose(
-            Rule,
-            [
-                TEMPLATE_MANAGER.render_template(CONFIG.templates.rule_requirement_template, {"rule_requirement": r})
-                for r in rule_reqs
-            ],
-            **kwargs,
-        )
-        if any(r for r in rules if r is None):
-            return None
-
-        ruleset_patch = await self.propose(
-            RuleSetMetadata,
-            f"{ruleset_requirement}\n\nYou should use `{detect_language(ruleset_requirement)}`!",
-            **override_kwargs(kwargs, default=None),
-        )
-
-        if ruleset_patch is None:
-            return None
-
-        return RuleSet(rules=rules, **ruleset_patch.as_kwargs())
-
-    async def check_string_against_rule(
-        self,
-        input_text: str,
-        rule: Rule,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
-    ) -> Optional[Improvement]:
-        """Validate text against specific rule.
-
-        Args:
-            input_text (str): Text content to validate
-            rule (Rule): Rule instance for validation
-            reference (str): Reference text for comparison (default: "")
-            **kwargs: Configuration for validation process
-
-        Returns:
-            Optional[Improvement]: Suggested improvement if violation detected
-
-        Notes:
-            - Uses `evidently_judge` to determine violation presence
-            - Renders template using `check_string_template` for proposal
-            - Proposes Improvement only when violation is confirmed
-        """
-        if judge := await self.evidently_judge(
-            f"# Content to exam\n{input_text}\n\n# Rule Must to follow\n{rule.display()}\nDoes `Content to exam` provided above violate the `{rule.name}` provided above?"
-            f"should I take some measure to fix that violation? true for I do need, false for I don't need.",
-            **override_kwargs(kwargs, default=None),
-        ):
-            logger.info(f"Rule `{rule.name}` violated: \n{judge.display()}")
-            return await self.propose(
-                Improvement,
-                TEMPLATE_MANAGER.render_template(
-                    CONFIG.templates.check_string_template,
-                    {"to_check": input_text, "rule": rule.display(), "judge": judge.display(), "reference": reference},
-                ),
-                **kwargs,
-            )
-        return None
-
-    async def check_obj_against_rule[M: (Display, WithBriefing)](
-        self,
-        obj: M,
-        rule: Rule,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
-    ) -> Optional[Improvement]:
-        """Validate object against rule using text representation.
-
-        Args:
-            obj (M): Object implementing Display/WithBriefing interface
-            rule (Rule): Validation rule
-            reference (str): Reference text for comparison (default: "")
-            **kwargs: Validation configuration parameters
-
-        Returns:
-            Optional[Improvement]: Improvement suggestion if issues found
-
-        Notes:
-            - Requires obj to implement display() or briefing property
-            - Raises TypeError for incompatible object types
-            - Converts object to text before string validation
-        """
-        if isinstance(obj, Display):
-            input_text = obj.display()
-        elif isinstance(obj, WithBriefing):
-            input_text = obj.briefing
-        else:
-            raise TypeError("obj must be either Display or WithBriefing")
-
-        return await self.check_string_against_rule(input_text, rule, reference, **kwargs)
-
-    async def check_string(
-        self,
-        input_text: str,
-        ruleset: RuleSet,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
-    ) -> Optional[List[Improvement]]:
-        """Validate text against full ruleset.
-
-        Args:
-            input_text (str): Text content to validate
-            ruleset (RuleSet): Collection of validation rules
-            reference (str): Reference text for comparison
-            **kwargs: Validation configuration parameters
-
-        Returns:
-            Optional[Improvement]: First detected improvement
-
-        Notes:
-            - Checks rules sequentially and returns first violation
-            - Halts validation after first successful improvement proposal
-            - Maintains rule execution order from ruleset.rules list
-        """
-        imp_seq = await gather(
-            *[self.check_string_against_rule(input_text, rule, reference, **kwargs) for rule in ruleset.rules]
-        )
-        if imp_seq is None:
-            logger.warning(f"Generation failed for string check against `{ruleset.name}`")
-            return None
-        return [imp for imp in imp_seq if imp]
-
-    async def check_obj[M: (Display, WithBriefing)](
-        self,
-        obj: M,
-        ruleset: RuleSet,
-        reference: str = "",
-        **kwargs: Unpack[ValidateKwargs[Improvement]],
-    ) -> Optional[List[Improvement]]:
-        """Validate object against full ruleset.
-
-        Args:
-            obj (M): Object implementing Display/WithBriefing interface
-            ruleset (RuleSet): Collection of validation rules
-            reference (str): Reference text for comparison (default: "")
-            **kwargs: Validation configuration parameters
-
-        Returns:
-            Optional[Improvement]: First detected improvement
-
-        Notes:
-            - Uses check_obj_against_rule for individual rule checks
-            - Maintains same early termination behavior as check_string
-            - Validates object through text conversion mechanism
-        """
-        imp_seq = await gather(*[self.check_obj_against_rule(obj, rule, reference, **kwargs) for rule in ruleset.rules])
-
-        if imp_seq is None:
-            logger.warning(f"Generation Failed for `{obj.__class__.__name__}` against Ruleset `{ruleset.name}`")
-            return None
-        return [i for i in imp_seq if i]