Refactor/return regexp support (#134)

* return regex module

* fix typing

* return test for regex

* rename modules

* make naming consistent: retriever -> embedding; prediction -> decision

* fix codestyle

* update schem

---------

Co-authored-by: Roman Solomatin <[email protected]>

Author: voorhs

autointent/_pipeline/_pipeline.py

@@ -11,15 +11,15 @@
 from autointent import Context, Dataset
 from autointent.configs import InferenceNodeConfig, LoggingConfig, VectorIndexConfig
 from autointent.custom_types import ListOfGenericLabels, NodeType, SamplerType, ValidationScheme
-from autointent.metrics import PREDICTION_METRICS
+from autointent.metrics import DECISION_METRICS
 from autointent.nodes import InferenceNode, NodeOptimizer
 from autointent.nodes.schemes import OptimizationConfig
 from autointent.utils import load_default_search_space, load_search_space
 
 from ._schemas import InferencePipelineOutput, InferencePipelineUtteranceOutput
 
 if TYPE_CHECKING:
-    from autointent.modules.abc import DecisionModule, ScoringModule
+    from autointent.modules.abc import BaseDecision, BaseScorer
 
 
 class Pipeline:
@@ -155,7 +155,7 @@ def fit(
             self._refit(context)
 
         predictions = self.predict(context.data_handler.test_utterances())
-        for metric_name, metric in PREDICTION_METRICS.items():
+        for metric_name, metric in DECISION_METRICS.items():
             context.optimization_info.pipeline_metrics[metric_name] = metric(
                 context.data_handler.test_labels(),
                 predictions,
@@ -218,8 +218,8 @@ def predict(self, utterances: list[str]) -> ListOfGenericLabels:
             msg = "Pipeline in optimization mode cannot perform inference"
             raise RuntimeError(msg)
 
-        scoring_module: ScoringModule = self.nodes[NodeType.scoring].module  # type: ignore[assignment,union-attr]
-        decision_module: DecisionModule = self.nodes[NodeType.decision].module  # type: ignore[assignment,union-attr]
+        scoring_module: BaseScorer = self.nodes[NodeType.scoring].module  # type: ignore[assignment,union-attr]
+        decision_module: BaseDecision = self.nodes[NodeType.decision].module  # type: ignore[assignment,union-attr]
 
         scores = scoring_module.predict(utterances)
         return decision_module.predict(scores)
@@ -235,8 +235,8 @@ def _refit(self, context: Context) -> None:
             msg = "Pipeline in optimization mode cannot perform inference"
             raise RuntimeError(msg)
 
-        scoring_module: ScoringModule = self.nodes[NodeType.scoring].module  # type: ignore[assignment,union-attr]
-        decision_module: DecisionModule = self.nodes[NodeType.decision].module  # type: ignore[assignment,union-attr]
+        scoring_module: BaseScorer = self.nodes[NodeType.scoring].module  # type: ignore[assignment,union-attr]
+        decision_module: BaseDecision = self.nodes[NodeType.decision].module  # type: ignore[assignment,union-attr]
 
         context.data_handler.prepare_for_refit()
 
@@ -258,9 +258,9 @@ def predict_with_metadata(self, utterances: list[str]) -> InferencePipelineOutpu
 
         scores, scores_metadata = self.nodes[NodeType.scoring].module.predict_with_metadata(utterances)  # type: ignore[union-attr]
         predictions = self.nodes[NodeType.decision].module.predict(scores)  # type: ignore[union-attr,arg-type]
-        regexp_predictions, regexp_predictions_metadata = None, None
-        if NodeType.regexp in self.nodes:
-            regexp_predictions, regexp_predictions_metadata = self.nodes[NodeType.regexp].module.predict_with_metadata(  # type: ignore[union-attr]
+        regex_predictions, regex_predictions_metadata = None, None
+        if NodeType.regex in self.nodes:
+            regex_predictions, regex_predictions_metadata = self.nodes[NodeType.regex].module.predict_with_metadata(  # type: ignore[union-attr]
                 utterances,
             )
 
@@ -269,9 +269,9 @@ def predict_with_metadata(self, utterances: list[str]) -> InferencePipelineOutpu
             output = InferencePipelineUtteranceOutput(
                 utterance=utterance,
                 prediction=predictions[idx],
-                regexp_prediction=regexp_predictions[idx] if regexp_predictions is not None else None,
-                regexp_prediction_metadata=regexp_predictions_metadata[idx]
-                if regexp_predictions_metadata is not None
+                regex_prediction=regex_predictions[idx] if regex_predictions is not None else None,
+                regex_prediction_metadata=regex_predictions_metadata[idx]
+                if regex_predictions_metadata is not None
                 else None,
                 score=scores[idx],
                 score_metadata=scores_metadata[idx] if scores_metadata is not None else None,
@@ -280,7 +280,7 @@ def predict_with_metadata(self, utterances: list[str]) -> InferencePipelineOutpu
 
         return InferencePipelineOutput(
             predictions=predictions,
-            regexp_predictions=regexp_predictions,
+            regex_predictions=regex_predictions,
             utterances=outputs,
         )
 

autointent/_pipeline/_schemas.py

@@ -10,8 +10,8 @@ class InferencePipelineUtteranceOutput(BaseModel):
 
     utterance: str
     prediction: LabelWithOOS
-    regexp_prediction: LabelWithOOS
-    regexp_prediction_metadata: Any
+    regex_prediction: LabelWithOOS
+    regex_prediction_metadata: Any
     score: list[float]
     score_metadata: Any
 
@@ -20,5 +20,5 @@ class InferencePipelineOutput(BaseModel):
     """Output of the inference pipeline."""
 
     predictions: ListOfLabelsWithOOS
-    regexp_predictions: ListOfLabels | None = None
+    regex_predictions: ListOfLabels | None = None
     utterances: list[InferencePipelineUtteranceOutput] | None = None

autointent/context/_context.py

@@ -172,5 +172,5 @@ def has_saved_modules(self) -> bool:
 
         :return: True if there are saved modules, False otherwise.
         """
-        node_types = ["regexp", "embedding", "scoring", "decision"]
+        node_types = ["regex", "embedding", "scoring", "decision"]
         return any(len(self.optimization_info.modules.get(nt)) > 0 for nt in node_types)

autointent/context/data_handler/_data_handler.py

@@ -20,9 +20,9 @@ class RegexPatterns(TypedDict):
 
     id: int
     """Intent class id."""
-    regexp_full_match: list[str]
+    regex_full_match: list[str]
     """Full match regex patterns."""
-    regexp_partial_match: list[str]
+    regex_partial_match: list[str]
     """Partial match regex patterns."""
 
 
@@ -59,11 +59,11 @@ def __init__(
         elif scheme == "cv":
             self._split_cv()
 
-        self.regexp_patterns = [
+        self.regex_patterns = [
             RegexPatterns(
                 id=intent.id,
-                regexp_full_match=intent.regexp_full_match,
-                regexp_partial_match=intent.regexp_partial_match,
+                regex_full_match=intent.regex_full_match,
+                regex_partial_match=intent.regex_partial_match,
             )
             for intent in self.dataset.intents
         ]

autointent/context/optimization_info/__init__.py

@@ -1,4 +1,4 @@
-from ._data_models import Artifact, DecisionArtifact, RetrieverArtifact, ScorerArtifact
+from ._data_models import Artifact, DecisionArtifact, EmbeddingArtifact, ScorerArtifact
 from ._optimization_info import OptimizationInfo
 
-__all__ = ["Artifact", "DecisionArtifact", "OptimizationInfo", "RetrieverArtifact", "ScorerArtifact"]
+__all__ = ["Artifact", "DecisionArtifact", "EmbeddingArtifact", "OptimizationInfo", "ScorerArtifact"]

autointent/context/optimization_info/_data_models.py

@@ -18,11 +18,11 @@ class Artifact(BaseModel):
     """Base class for artifacts generated by pipeline nodes."""
 
 
-class RegexpArtifact(Artifact):
-    """Artifact containing results from the regexp node."""
+class RegexArtifact(Artifact):
+    """Artifact containing results from the regex node."""
 
 
-class RetrieverArtifact(Artifact):
+class EmbeddingArtifact(Artifact):
     """
     Artifact containing details from the embedding node.
 
@@ -68,9 +68,9 @@ def validate_node_name(value: str) -> str:
     :return: Validated node type string.
     :raises ValueError: If the node type is invalid.
     """
-    if value in [NodeType.embedding, NodeType.scoring, NodeType.decision, NodeType.regexp]:
+    if value in [NodeType.embedding, NodeType.scoring, NodeType.decision, NodeType.regex]:
         return value
-    msg = f"Unknown node_type: {value}. Expected one of ['regexp', 'embedding', 'scoring', 'decision']"
+    msg = f"Unknown node_type: {value}. Expected one of ['regex', 'embedding', 'scoring', 'decision']"
     raise ValueError(msg)
 
 
@@ -83,8 +83,8 @@ class Artifacts(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    regexp: list[RegexpArtifact] = []
-    embedding: list[RetrieverArtifact] = []
+    regex: list[RegexArtifact] = []
+    embedding: list[EmbeddingArtifact] = []
     scoring: list[ScorerArtifact] = []
     decision: list[DecisionArtifact] = []
 
@@ -135,7 +135,7 @@ class Trial(BaseModel):
 class Trials(BaseModel):
     """Container for managing optimization trials for pipeline nodes."""
 
-    regexp: list[Trial] = []
+    regex: list[Trial] = []
     embedding: list[Trial] = []
     scoring: list[Trial] = []
     decision: list[Trial] = []
@@ -172,8 +172,8 @@ def add_trial(self, node_type: str, trial: Trial) -> None:
 class TrialsIds(BaseModel):
     """Representation of the best trial IDs for each pipeline node."""
 
-    regexp: int | None = None
-    """Best trial index for the regexp node."""
+    regex: int | None = None
+    """Best trial index for the regex node."""
     embedding: int | None = None
     """Best trial index for the embedding node."""
     scoring: int | None = None

autointent/context/optimization_info/_optimization_info.py

@@ -15,31 +15,31 @@
 from autointent.custom_types import NodeType
 from autointent.schemas import EmbedderConfig
 
-from ._data_models import Artifact, Artifacts, RetrieverArtifact, ScorerArtifact, Trial, Trials, TrialsIds
+from ._data_models import Artifact, Artifacts, EmbeddingArtifact, ScorerArtifact, Trial, Trials, TrialsIds
 
 if TYPE_CHECKING:
-    from autointent.modules.abc import Module
+    from autointent.modules.abc import BaseModule
 
 
 @dataclass
 class ModulesList:
     """Container for managing lists of modules for each node type."""
 
-    regexp: list["Module"] = field(default_factory=list)
-    embedding: list["Module"] = field(default_factory=list)
-    scoring: list["Module"] = field(default_factory=list)
-    decision: list["Module"] = field(default_factory=list)
+    regex: list["BaseModule"] = field(default_factory=list)
+    embedding: list["BaseModule"] = field(default_factory=list)
+    scoring: list["BaseModule"] = field(default_factory=list)
+    decision: list["BaseModule"] = field(default_factory=list)
 
-    def get(self, node_type: str) -> list["Module"]:
+    def get(self, node_type: str) -> list["BaseModule"]:
         """
         Retrieve the list of modules for a specific node type.
 
-        :param node_type: The type of node (e.g., "regexp", "embedding").
+        :param node_type: The type of node (e.g., "regex", "embedding").
         :return: List of modules for the specified node type.
         """
         return getattr(self, node_type)  # type: ignore[no-any-return]
 
-    def add_module(self, node_type: str, module: "Module") -> None:
+    def add_module(self, node_type: str, module: "BaseModule") -> None:
         """
         Add a module to the list for a specific node type.
 
@@ -77,7 +77,7 @@ def log_module_optimization(
         metric_name: str,
         artifact: Artifact,
         module_dump_dir: str | None,
-        module: "Module | None" = None,
+        module: "BaseModule | None" = None,
     ) -> None:
         """
         Log optimization results for a module.
@@ -126,7 +126,7 @@ def _get_best_trial_idx(self, node_type: str) -> int | None:
         self._trials_best_ids.set_best_trial_idx(node_type, best_idx)
         return best_idx
 
-    def _get_best_artifact(self, node_type: str) -> RetrieverArtifact | ScorerArtifact | Artifact:
+    def _get_best_artifact(self, node_type: str) -> EmbeddingArtifact | ScorerArtifact | Artifact:
         """
         Retrieve the best artifact for a specific node type.
 
@@ -146,7 +146,7 @@ def get_best_embedder(self) -> EmbedderConfig:
 
         :return: Name of the best embedder.
         """
-        best_retriever_artifact: RetrieverArtifact = self._get_best_artifact(node_type=NodeType.embedding)  # type: ignore[assignment]
+        best_retriever_artifact: EmbeddingArtifact = self._get_best_artifact(node_type=NodeType.embedding)  # type: ignore[assignment]
         return best_retriever_artifact.config
 
     def get_best_train_scores(self) -> NDArray[np.float64] | None:
@@ -219,7 +219,7 @@ def get_inference_nodes_config(self, asdict: bool = False) -> list[InferenceNode
             res.append(item if asdict else InferenceNodeConfig(**item))  # type: ignore[arg-type]
         return res  # type: ignore[return-value]
 
-    def _get_best_module(self, node_type: str) -> "Module | None":
+    def _get_best_module(self, node_type: str) -> "BaseModule | None":
         """
         Retrieve the best module for a specific node type.
 
@@ -231,7 +231,7 @@ def _get_best_module(self, node_type: str) -> "Module | None":
             return self.modules.get(node_type)[idx]
         return None
 
-    def get_best_modules(self) -> dict[NodeType, "Module"]:
+    def get_best_modules(self) -> dict[NodeType, "BaseModule"]:
         """
         Retrieve the best modules for all node types.
 

autointent/custom_types.py

@@ -51,7 +51,7 @@ class LogLevel(Enum):
 class NodeType(str, Enum):
     """Enumeration of node types in the AutoIntent pipeline."""
 
-    regexp = "regexp"
+    regex = "regex"
     embedding = "embedding"
     scoring = "scoring"
     decision = "decision"

autointent/generation/intents/description_generation.py

@@ -38,7 +38,7 @@ async def create_intent_description(
     client: AsyncOpenAI,
     intent_name: str | None,
     utterances: list[str],
-    regexp_patterns: list[str],
+    regex_patterns: list[str],
     prompt: PromptDescription,
     model_name: str,
 ) -> str:
@@ -48,7 +48,7 @@ async def create_intent_description(
     :param client: The OpenAI client instance used to communicate with the model.
     :param intent_name: The name of the intent to describe. If None, an empty string will be used.
     :param utterances: A list of example utterances related to the intent.
-    :param regexp_patterns: A list of regular expression patterns associated with the intent.
+    :param regex_patterns: A list of regular expression patterns associated with the intent.
 
     :param prompt: A string template for the prompt, which must include placeholders for {intent_name}
                                     and {user_utterances} to format the content sent to the model.
@@ -58,12 +58,12 @@ async def create_intent_description(
     """
     intent_name = intent_name if intent_name is not None else ""
     utterances = random.sample(utterances, min(5, len(utterances)))
-    regexp_patterns = random.sample(regexp_patterns, min(3, len(regexp_patterns)))
+    regex_patterns = random.sample(regex_patterns, min(3, len(regex_patterns)))
 
     content = prompt.text.format(
         intent_name=intent_name,
         user_utterances="\n".join(utterances),
-        regexp_patterns="\n".join(regexp_patterns),
+        regex_patterns="\n".join(regex_patterns),
     )
     chat_completion = await client.chat.completions.create(
         messages=[{"role": "user", "content": content}],
@@ -102,13 +102,13 @@ async def generate_intent_descriptions(
         if intent.description is not None:
             continue
         utterances = intent_utterances.get(intent.id, [])
-        regexp_patterns = intent.regexp_full_match + intent.regexp_partial_match
+        regex_patterns = intent.regex_full_match + intent.regex_partial_match
         task = asyncio.create_task(
             create_intent_description(
                 client=client,
                 intent_name=intent.name,
                 utterances=utterances,
-                regexp_patterns=regexp_patterns,
+                regex_patterns=regex_patterns,
                 prompt=prompt,
                 model_name=model_name,
             ),

autointent/generation/intents/prompt_scheme.py

@@ -14,7 +14,7 @@ class PromptDescription(BaseModel):
     Should include placeholders for {intent_name} and {user_utterances}.
     - `{intent_name}` will be replaced with the name of the intent.
     - `{user_utterances}` will be replaced with the user utterances related to the intent.
-    - (optionally) `{regexp_patterns}` will be replaced with the regular expressions that match user utterances.
+    - (optionally) `{regex_patterns}` will be replaced with the regular expressions that match user utterances.
     """
 
     @classmethod