wisent 0.1.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

wisent/core/prompts/core/atom.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import TypedDict
+
+__all__ = [
+    "ChatMessage",
+    "PromptPair",
+    "PromptStrategy",
+    "UnknownStrategyError",
+]
+
+class ChatMessage(TypedDict):
+    """A single chat message compatible with common chat model APIs."""
+    role: str
+    content: str
+
+
+@dataclass(frozen=True)
+class PromptPair:
+    """A pair of prompts for positive and negative training/eval cases."""
+    positive: list[ChatMessage]
+    negative: list[ChatMessage]
+
+class PromptStrategy(ABC):
+    """Abstract strategy for building a PromptPair from QA text.
+
+    Subclasses MUST define a unique, non-empty class attribute:
+        strategy_key: str
+    """
+
+    strategy_key: str
+
+    def __init_subclass__(cls, **kwargs):  # type: ignore[override]
+        super().__init_subclass__(**kwargs)
+        key = getattr(cls, "strategy_key", None)
+        if not isinstance(key, str) or not key.strip():
+            raise TypeError(
+                f"{cls.__name__} must define a non-empty class attribute "
+                "'strategy_key: str'."
+            )
+
+    @abstractmethod
+    def build(
+        self,
+        question: str,
+        correct_answer: str,
+        incorrect_answer: str,
+    ) -> PromptPair:
+        """Construct positive/negative prompts from the given QA trio."""
+        raise NotImplementedError
+
+
+class UnknownStrategyError(ValueError):
+    """Raised when a requested strategy key does not exist."""
+    pass

wisent/core/prompts/core/prompt_formater.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import pkgutil
+from typing import Iterable, Type
+
+from wisent.core.prompts.core.atom import PromptPair, PromptStrategy, UnknownStrategyError
+
+__all__ = ["PromptFormatter", "StrategyKey", "UnknownStrategyError"]
+
+StrategyKey = str | type[PromptStrategy]
+
+
+class PromptFormatter:
+    """Main entry point for building prompt pairs via discovered strategies.
+
+    atributes:
+        _registry: Maps strategy_key to PromptStrategy subclass.
+    
+    methods:
+        format: 
+            Build a PromptPair using a discovered strategy.
+        available: 
+            Return the available strategy keys.
+        refresh: 
+            Rescan the 'strategies' package for newly added strategy files.
+    """
+
+    def __init__(self) -> None:
+        self._registry: dict[str, Type[PromptStrategy]] = {}
+        self._discover_and_load()
+
+    def format(
+        self,
+        strategy: StrategyKey,
+        question: str,
+        correct_answer: str,
+        incorrect_answer: str,
+    ) -> PromptPair:
+        """Build a PromptPair using a discovered strategy.
+        
+        arguments:
+            strategy: The strategy key (string) or PromptStrategy subclass.
+            question: The question text.
+            correct_answer: The correct answer text.
+            incorrect_answer: The incorrect answer text.
+        
+        returns:
+            A PromptPair constructed by the specified strategy.
+
+        raises:
+            UnknownStrategyError: If the strategy key is not found.
+            TypeError: If the strategy argument is not a string or PromptStrategy subclass.
+
+        example:
+            >>> formatter = PromptFormatter()
+            >>> pair = formatter.format(
+            ...     strategy="multiple_choice",
+            ...     question="What is 2+2?",
+            ...     correct_answer="4",
+            ...     incorrect_answer="5"
+            ... )
+            >>> print(pair)
+            PromptPair(
+                positive=[{'role': 'user', 'content': 'Which is better: What is 2+2? A. 5 B. 4'}, {'role': 'assistant', 'content': 'B'}],
+                negative=[{'role': 'user', 'content': 'Which is better: What is 2+2? A. 5 B. 4'}, {'role': 'assistant', 'content': 'A'}])
+        """
+        key = self._normalize_key(strategy)
+        try:
+            strategy_cls = self._registry[key]
+        except KeyError as exc:
+            raise UnknownStrategyError(f"Unknown strategy: {strategy!r}") from exc
+
+        pair = strategy_cls().build(question, correct_answer, incorrect_answer)
+        return pair
+
+    def available(self) -> Iterable[str]:
+        """Return the available strategy keys.
+
+        returns:
+            An iterable of available strategy keys.
+        
+        example:
+            >>> formatter = PromptFormatter()
+            >>> print(formatter.available())
+            ('multiple_choice', 'role_playing', 'instruction_following')
+        """
+        return tuple(sorted(self._registry.keys()))
+
+    def refresh(self) -> None:
+        """Rescan the 'strategies' package for newly added strategy files."""
+        self._registry.clear()
+        self._discover_and_load()
+
+    @staticmethod
+    def _normalize_key(key: StrategyKey) -> str:
+        if isinstance(key, str):
+            return key
+        if inspect.isclass(key) and issubclass(key, PromptStrategy):
+            return key.strategy_key
+        raise TypeError(
+            "strategy must be a string key or a PromptStrategy subclass."
+        )
+
+    def _discover_and_load(self) -> None:
+        """Import all modules in the 'strategies' package and collect strategies.
+        
+        raises:
+            RuntimeError: If the 'strategies' package is not found or no strategies are discovered.
+        """
+        try:
+            import wisent_guard.core.prompts.prompt_stratiegies as strategies_pkg
+        except ModuleNotFoundError as exc:
+            raise RuntimeError(
+                "The 'strategies' package was not found. "
+                "Create a 'strategies' directory with an empty __init__.py."
+            ) from exc
+
+        import wisent_guard.core.prompts.prompt_stratiegies as strategies_pkg
+
+        for module_info in pkgutil.iter_modules(strategies_pkg.__path__):
+            name = module_info.name
+            if name.startswith("_"):
+                # Skip private/dunder modules.
+                continue
+
+            module = importlib.import_module(f"strategies.{name}")
+            self._register_strategies_from_module(module)
+
+        if not self._registry:
+            raise RuntimeError(
+                "No strategies found. Add at least one file in 'strategies/' "
+                "defining a PromptStrategy subclass with a unique 'strategy_key'."
+            )
+
+    def _register_strategies_from_module(self, module) -> None:
+        '''
+        Inspect the given module for PromptStrategy subclasses and register them.
+        
+        arguments:
+            module: The imported module to inspect.
+        
+        raises:
+            RuntimeError: If duplicate strategy_key values are found.
+        '''
+        for _, obj in inspect.getmembers(module, inspect.isclass):
+            if not issubclass(obj, PromptStrategy) or obj is PromptStrategy:
+                continue
+            key = obj.strategy_key
+            if key in self._registry:
+                existing = self._registry[key].__module__
+                raise RuntimeError(
+                    f"Duplicate strategy_key '{key}' found in module "
+                    f"'{module.__name__}' (already defined in '{existing}')."
+                )
+            self._registry[key] = obj

wisent/core/prompts/prompt_stratiegies/direct_completion.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from wisent.core.prompts.core.atom import ChatMessage, PromptPair, PromptStrategy
+
+__all__ = ["DirectCompletionStrategy"]
+
+class DirectCompletionStrategy(PromptStrategy):
+    """Direct completion strategy: question from user, answer from assistant."""
+
+    def build(
+        self,
+        question: str,
+        correct_answer: str,
+        incorrect_answer: str,
+    ) -> PromptPair:
+        pos: list[ChatMessage] = [
+            {"role": "user", "content": question},
+            {"role": "assistant", "content": correct_answer},
+        ]
+        neg: list[ChatMessage] = [
+            {"role": "user", "content": question},
+            {"role": "assistant", "content": incorrect_answer},
+        ]
+        return PromptPair(positive=pos, negative=neg)

wisent/core/prompts/prompt_stratiegies/instruction_following.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from wisent.core.prompts.core.atom import ChatMessage, PromptPair, PromptStrategy
+
+__all__ = ["InstructionFollowingStrategy"]
+
+class InstructionFollowingStrategy(PromptStrategy):
+    """Plain instruction/QA style: question from user, answer from assistant."""
+
+    def build(
+        self,
+        question: str,
+        correct_answer: str,
+        incorrect_answer: str,
+    ) -> PromptPair:
+        pos: list[ChatMessage] = [
+            {"role": "user", "content": question},
+            {"role": "assistant", "content": correct_answer},
+        ]
+        neg: list[ChatMessage] = [
+            {"role": "user", "content": question},
+            {"role": "assistant", "content": incorrect_answer},
+        ]
+        return PromptPair(positive=pos, negative=neg)

wisent/core/prompts/prompt_stratiegies/multiple_choice.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from wisent.core.prompts.core.atom import ChatMessage, PromptPair, PromptStrategy
+
+__all__ = ["MultipleChoiceStrategy"]
+
+class MultipleChoiceStrategy(PromptStrategy):
+    """Formats a multiple-choice prompt with options A/B."""
+
+    def build(
+        self,
+        question: str,
+        correct_answer: str,
+        incorrect_answer: str,
+    ) -> PromptPair:
+        mc_q = (
+            f"Which is better: {question} "
+            f"A. {incorrect_answer} B. {correct_answer}"
+        )
+
+        pos: list[ChatMessage] = [
+            {"role": "user", "content": mc_q},
+            {"role": "assistant", "content": "B"},
+        ]
+        neg: list[ChatMessage] = [
+            {"role": "user", "content": mc_q},
+            {"role": "assistant", "content": "A"},
+        ]
+        return PromptPair(positive=pos, negative=neg)

wisent/core/prompts/prompt_stratiegies/role_playing.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from wisent.core.prompts.core.atom import ChatMessage, PromptPair, PromptStrategy
+
+__all__ = ["RolePlayingStrategy"]
+
+class RolePlayingStrategy(PromptStrategy):
+    """Asks the model to behave like someone who gives a specific answer."""
+
+    def build(
+        self,
+        question: str,
+        correct_answer: str,
+        incorrect_answer: str,
+    ) -> PromptPair:
+        positive_instruction = (
+            f"Behave like a person that would answer {question} with {correct_answer}"
+        )
+        negative_instruction = (
+            f"Behave like a person that would answer {question} with {incorrect_answer}"
+        )
+
+        pos: list[ChatMessage] = [
+            {"role": "user", "content": positive_instruction},
+            {"role": "assistant", "content": correct_answer},
+        ]
+        neg: list[ChatMessage] = [
+            {"role": "user", "content": negative_instruction},
+            {"role": "assistant", "content": incorrect_answer},
+        ]
+        return PromptPair(positive=pos, negative=neg)

wisent/core/representation.py

@@ -0,0 +1,5 @@
+class Representation:
+    def __init__(self, tensor, layer, aggregation_method=None):
+        self.tensor = tensor
+        self.layer = layer
+        self.aggregation_method = aggregation_method