wisent 0.5.12__py3-none-any.whl → 0.5.14__py3-none-any.whl

wisent/classifiers/models/logistic.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-import torch
-from torch import nn
-
-from wisent.classifiers.core.atoms import BaseClassifier
-
-__all__ = ["LogisticClassifier"]
-
-class LogisticModel(nn.Module):
-    """Simple logistic regression model for activation classification."""
-    def __init__(self, input_dim: int):
-        super().__init__()
-        self.linear = nn.Linear(input_dim, 1)
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        logits = self.linear(x)
-        if logits.ndim == 1:
-            logits = logits.unsqueeze(1)
-        return self.sigmoid(logits)
-
-
-class LogisticClassifier(BaseClassifier):
-    name = "logistic"
-    description = "One-layer logistic regression over dense features"
-
-    def build_model(self, input_dim: int, **_: object) -> nn.Module:
-        return LogisticModel(input_dim)

wisent/classifiers/models/mlp.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-import torch
-from torch import nn
-
-from wisent.classifiers.core.atoms import BaseClassifier
-
-__all__ = ["MLPClassifier"]
-
-class MLPModel(nn.Module):
-    """Multi-layer perceptron for activation classification."""
-    def __init__(self, input_dim: int, hidden_dim: int = 128, dropout: float = 0.2):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.Linear(input_dim, hidden_dim),
-            nn.ReLU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, hidden_dim // 2),
-            nn.ReLU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim // 2, 1),
-            nn.Sigmoid(),
-        )
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = self.net(x)
-        if out.ndim == 1:
-            out = out.unsqueeze(1)
-        return out
-
-
-class MLPClassifier(BaseClassifier):
-    name = "mlp"
-    description = "Two-layer MLP with dropout and ReLU"
-
-    def __init__(self, *, hidden_dim: int = 128, **base_kwargs):
-        super().__init__(**base_kwargs)
-        self._hidden_dim = int(hidden_dim)
-
-    def build_model(self, input_dim: int, **model_params: object) -> nn.Module:
-        hd = int(model_params.get("hidden_dim", self._hidden_dim))  
-        dp = float(model_params.get("dropout", 0.2))
-        self._hidden_dim = hd
-        return MLPModel(input_dim, hidden_dim=hd, dropout=dp)
-
-    def model_hyperparams(self) -> dict[str, int]:
-        return {"hidden_dim": self._hidden_dim, "dropout": 0.2}

wisent/cli/classifiers/classifier_rotator.py

@@ -1,137 +0,0 @@
-from __future__ import annotations
-
-import importlib
-import importlib.util
-import inspect
-import pkgutil
-from pathlib import Path
-from typing import Any
-
-from wisent.core.classifiers.core.atoms import BaseClassifier, ClassifierError, ClassifierTrainReport
-
-__all__ = ["ClassifierRotator"]
-
-class ClassifierRotator:
-    """
-    Discover, list, and delegate to registered classifiers.
-    """
-
-    def __init__(
-        self,
-        classifier: str | BaseClassifier | type[BaseClassifier] | None = None,
-        classifiers_location: str | Path = "wisent_guard.core.classifiers.models",
-        autoload: bool = True,
-        **classifier_kwargs: Any,
-    ) -> None:
-        if autoload:
-            self.discover_classifiers(classifiers_location)
-        self._classifier = self._resolve_classifier(classifier, **classifier_kwargs)
-
-    @staticmethod
-    def discover_classifiers(location: str | Path = "wisent_guard.core.classifiers.models") -> None:
-        """
-        Import all classifier modules so BaseClassifier subclasses self-register.
-
-        - If `location` is a dotted module path (str without existing FS path),
-          import that package and iterate its __path__ (works with namespace packages).
-        - If `location` is an existing directory (Path/str), import all .py files inside.
-        """
-        loc_path = Path(str(location))
-        if loc_path.exists() and loc_path.is_dir():
-            ClassifierRotator._import_all_py_in_dir(loc_path)
-            return
-
-        if not isinstance(location, str):
-            raise ClassifierError(
-                f"Invalid classifiers location: {location!r}. Provide a dotted module path or a directory."
-            )
-
-        try:
-            pkg = importlib.import_module(location)
-        except ModuleNotFoundError as exc:
-            raise ClassifierError(
-                f"Cannot import classifier package {location!r}. "
-                f"Use a dotted path (no leading slash) and ensure your project root is on PYTHONPATH."
-            ) from exc
-
-        search_paths = list(getattr(pkg, "__path__", []))
-        if not search_paths:
-            pkg_file = getattr(pkg, "__file__", None)
-            if pkg_file:
-                search_paths = [str(Path(pkg_file).parent)]
-
-        for _finder, name, _ispkg in pkgutil.iter_modules(search_paths):
-            if name.startswith("_"):
-                continue
-            importlib.import_module(f"{location}.{name}")
-
-    @staticmethod
-    def _import_all_py_in_dir(directory: Path) -> None:
-        for py in directory.glob("*.py"):
-            if py.name.startswith("_"):
-                continue
-            mod_name = f"_dyn_classifiers_{py.stem}"
-            spec = importlib.util.spec_from_file_location(mod_name, py)
-            if spec and spec.loader:
-                module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(module)  # type: ignore[attr-defined]
-
-    @staticmethod
-    def list_classifiers() -> list[dict[str, Any]]:
-        out: list[dict[str, Any]] = []
-        for name, cls in BaseClassifier.list_registered().items():
-            out.append(
-                {
-                    "name": name,
-                    "description": getattr(cls, "description", ""),
-                    "class": f"{cls.__module__}.{cls.__name__}",
-                }
-            )
-        return sorted(out, key=lambda x: x["name"])
-
-    @staticmethod
-    def _resolve_classifier(
-        classifier: str | BaseClassifier | type[BaseClassifier] | None,
-        **kwargs: Any,
-    ) -> BaseClassifier:
-        if classifier is None:
-            registry = BaseClassifier.list_registered()
-            if not registry:
-                raise ClassifierError("No classifiers registered.")
-            # Deterministic pick: first by name
-            return next(iter(sorted(registry.items())))[1](**kwargs)
-        if isinstance(classifier, BaseClassifier):
-            return classifier
-        if inspect.isclass(classifier) and issubclass(classifier, BaseClassifier):
-            return classifier(**kwargs)
-        if isinstance(classifier, str):
-            cls = BaseClassifier.get(classifier)
-            return cls(**kwargs)
-        raise TypeError(
-            "classifier must be None, a name (str), BaseClassifier instance, or BaseClassifier subclass."
-        )
-
-
-    def use(self, classifier: str | BaseClassifier | type[BaseClassifier], **kwargs: Any) -> None:
-        self._classifier = self._resolve_classifier(classifier, **kwargs)
-
-    def fit(self, X, y, **kwargs) -> ClassifierTrainReport:
-        return self._classifier.fit(X, y, **kwargs)
-
-    def predict(self, X):
-        return self._classifier.predict(X)
-
-    def predict_proba(self, X):
-        return self._classifier.predict_proba(X)
-
-    def evaluate(self, X, y) -> dict[str, float]:
-        return self._classifier.evaluate(X, y)
-
-    def save_model(self, path: str) -> None:
-        self._classifier.save_model(path)
-
-    def load_model(self, path: str) -> None:
-        self._classifier.load_model(path)
-
-    def set_threshold(self, threshold: float) -> None:
-        self._classifier.set_threshold(threshold)

wisent/cli/cli_logger.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-import sys
-from datetime import datetime, timezone
-from typing import Any, Mapping
-
-__all__ = [
-    "setup_logger",
-    "bind",
-    "JsonFormatter",
-    "ContextAdapter",
-    "add_file_handler",
-]
-
-class JsonFormatter(logging.Formatter):
-    """
-    Minimal JSON formatter with structured fields + extras.
-    """
-    _STD = {
-        "name", "msg", "args", "levelname", "levelno", "pathname",
-        "filename", "module", "exc_info", "exc_text", "stack_info",
-        "lineno", "funcName", "created", "msecs", "relativeCreated",
-        "thread", "threadName", "processName", "process"
-    }
-
-    def format(self, record: logging.LogRecord) -> str:
-        payload: dict[str, Any] = {
-            "ts": datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat(),
-            "level": record.levelname,
-            "logger": record.name,
-            "message": record.getMessage(),
-            "file": record.filename,
-            "func": record.funcName,
-            "line": record.lineno,
-        }
-        extras = {
-            k: v for k, v in record.__dict__.items()
-            if k not in self._STD and not k.startswith("_")
-        }
-        if extras:
-            payload["extra"] = extras
-        if record.exc_info:
-            payload["exc"] = self.formatException(record.exc_info)
-        return json.dumps(payload, ensure_ascii=False)
-
-
-class ContextAdapter(logging.LoggerAdapter):
-    """
-    LoggerAdapter that ensures persistent context fields appear in every log entry.
-    """
-    def process(self, msg, kwargs):
-        extra = kwargs.get("extra", {})
-        extra.update(self.extra or {})
-        kwargs["extra"] = extra
-        return msg, kwargs
-
-
-class _EnsureContextFilter(logging.Filter):
-    """
-    Adds default values for context keys so format strings never KeyError.
-    """
-    def __init__(self, defaults: Mapping[str, Any] | None = None):
-        super().__init__()
-        self.defaults = dict(defaults or {})
-
-    def filter(self, record: logging.LogRecord) -> bool:
-        for k, v in self.defaults.items():
-            if not hasattr(record, k):
-                setattr(record, k, v)
-        return True
-
-
-def setup_logger(
-    name: str = "wisent",
-    level: int = logging.INFO,
-    *,
-    json_logs: bool = False,
-    stream = sys.stderr,
-) -> logging.Logger:
-    """
-    Create or return a named logger with a single stream handler.
-    Safe to call multiple times; won’t duplicate handlers.
-    """
-    logger = logging.getLogger(name)
-    logger.setLevel(level)
-    if not logger.handlers:
-        handler = logging.StreamHandler(stream)
-        if json_logs:
-            handler.setFormatter(JsonFormatter())
-        else:
-            handler.setFormatter(logging.Formatter(
-                fmt="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s "
-                    "[file=%(filename)s func=%(funcName)s line=%(lineno)d] "
-                    "%(task_name)s%(subtask)s",
-                datefmt="%Y-%m-%dT%H:%M:%S%z",
-            ))
-        # ensure context placeholders always exist
-        handler.addFilter(_EnsureContextFilter({"task_name": "", "subtask": ""}))
-        logger.addHandler(handler)
-        logger.propagate = False
-    return logger
-
-
-def add_file_handler(
-    logger: logging.Logger,
-    filepath: str,
-    *,
-    level: int | None = None,
-    json_logs: bool = False,
-) -> None:
-    """
-    Optionally add a file handler (e.g., for long-running CLI jobs).
-    """
-    fh = logging.FileHandler(filepath, encoding="utf-8")
-    fh.setLevel(level or logger.level)
-    if json_logs:
-        fh.setFormatter(JsonFormatter())
-    else:
-        fh.setFormatter(logging.Formatter(
-            fmt="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s "
-                "[file=%(filename)s func=%(funcName)s line=%(lineno)d] "
-                "%(task_name)s%(subtask)s",
-            datefmt="%Y-%m-%dT%H:%M:%S%z",
-        ))
-    fh.addFilter(_EnsureContextFilter({"task_name": "", "subtask": ""}))
-    logger.addHandler(fh)
-
-
-def bind(
-    logger: logging.Logger | ContextAdapter,
-    **extra: Any
-) -> ContextAdapter:
-    """
-    Return a ContextAdapter with merged extras.
-    Works whether you pass a raw Logger or an existing ContextAdapter.
-    """
-    if isinstance(logger, ContextAdapter):
-        merged = {**logger.extra, **extra}
-        return ContextAdapter(logger.logger, merged)
-    return ContextAdapter(logger, extra)

wisent/cli/wisent_cli/commands/help_cmd.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-import shlex
-from typing import Optional
-import typer
-
-__all__ = ["app", "help_command"]
-
-app = typer.Typer(help="Human-friendly help router")
-
-def _run_cli_line(line: str) -> None:
-    from typer.main import get_command
-    from wisent.cli.wisent_cli.main import app as root_app
-    click_cmd = get_command(root_app)
-    args = shlex.split(line)
-    try:
-        click_cmd.main(args=args, standalone_mode=False, prog_name="wisent")
-    except SystemExit as e:
-        if e.code not in (0, None):
-            raise
-
-@app.command("help")
-def help_command(topic: Optional[str] = typer.Argument(None), name: Optional[str] = typer.Argument(None)):
-    """
-    Examples:
-      wisent help train
-      wisent help method caa
-      wisent help loader custom
-      wisent help list-methods
-    """
-    t = (topic or "").strip().lower()
-
-    if t in {"", "app", "main"}:
-        _run_cli_line("--help")
-        return
-
-    passthrough = {"train", "list-methods", "list-loaders", "list-aggregations", "explain", "instructions", "start"}
-    if t in passthrough:
-        _run_cli_line(f"{t} --help")
-        return
-
-    if t in {"method", "methods"} and name:
-        _run_cli_line(f"explain --method {shlex.quote(name)}")
-        return
-    if t in {"loader", "loaders"} and name:
-        _run_cli_line(f"explain --loader {shlex.quote(name)}")
-        _run_cli_line(f"loader-args {shlex.quote(name)}")
-        return
-    if t in {"aggregation", "agg", "aggregations"} and name:
-        _run_cli_line(f"explain --aggregation {shlex.quote(name)}")
-        return
-
-    _run_cli_line("--help")

wisent/cli/wisent_cli/commands/listing.py

@@ -1,154 +0,0 @@
-from __future__ import annotations
-import inspect
-from typing import Optional
-
-import typer
-
-from wisent.cli.wisent_cli.ui import echo
-from wisent.cli.wisent_cli.util import aggregations as aggs
-
-try:
-    from rich.table import Table
-    from rich.panel import Panel
-    HAS_RICH = True
-except Exception:
-    HAS_RICH = False
-
-app = typer.Typer(help="Listing, discovery, and explanation commands")
-
-
-@app.command("list-aggregations")
-def list_aggregations():
-    if HAS_RICH:
-        t = Table(title="Aggregation Strategies")
-        t.add_column("Name", style="bold")
-        t.add_column("Description")
-        for k, desc in aggs.descriptions().items():
-            t.add_row(k.name.lower(), desc)
-        echo(t)
-    else:
-        for k, desc in aggs.descriptions().items():
-            print(f"- {k.name.lower():22s} : {desc}")
-
-
-@app.command("list-methods")
-def list_methods():
-    from wisent.cli.steering_methods.steering_rotator import SteeringMethodRotator  # type: ignore
-    rot = SteeringMethodRotator()
-    methods = rot.list_methods()
-    if not methods:
-        typer.echo("No steering methods registered.")
-        raise typer.Exit(code=1)
-    if HAS_RICH:
-        t = Table(title="Registered Steering Methods")
-        t.add_column("Name", style="bold")
-        t.add_column("Description")
-        t.add_column("Class")
-        for m in methods:
-            t.add_row(m["name"], m["description"], m["class"])
-        echo(t)
-    else:
-        for m in methods:
-            print(f"- {m['name']}: {m['description']} ({m['class']})")
-
-
-@app.command("list-loaders")
-def list_loaders(
-    loaders_location: Optional[str] = typer.Option(None, help="Package path or directory containing data loader modules"),
-    scope_prefix: Optional[str] = typer.Option(None, help="Limit list to module path prefix"),
-):
-    from wisent.cli.data_loaders.data_loader_rotator import DataLoaderRotator  # type: ignore
-    if loaders_location:
-        DataLoaderRotator.discover_loaders(loaders_location)
-    loaders = DataLoaderRotator.list_loaders(scope_prefix=scope_prefix)
-    if not loaders:
-        typer.echo("No data loaders found.")
-        raise typer.Exit(code=1)
-    if HAS_RICH:
-        t = Table(title="Registered Data Loaders")
-        t.add_column("Name", style="bold")
-        t.add_column("Description")
-        t.add_column("Class")
-        for l in loaders:
-            t.add_row(l["name"], l["description"], l["class"])
-        echo(t)
-    else:
-        for l in loaders:
-            print(f"- {l['name']}: {l['description']} ({l['class']})")
-
-
-@app.command("explain")
-def explain(
-    method: Optional[str] = typer.Option(None, help="Steering method to describe"),
-    loader: Optional[str] = typer.Option(None, help="Data loader to describe"),
-    loaders_location: Optional[str] = typer.Option(None, help="Where to discover data loaders"),
-    aggregation: Optional[str] = typer.Option(None, help="Aggregation to describe"),
-):
-    from wisent.cli.data_loaders.data_loader_rotator import DataLoaderRotator  # type: ignore
-    from wisent.cli.steering_methods.steering_rotator import SteeringMethodRotator  # type: ignore
-
-    if loaders_location:
-        DataLoaderRotator.discover_loaders(loaders_location)
-
-    if method:
-        m = SteeringMethodRotator._resolve_method(method)
-        doc = (getattr(type(m), "__doc__", None) or "No docstring.").strip()
-        if HAS_RICH:
-            echo(Panel(doc, title=f"Method: {getattr(m, 'name', type(m).__name__)}"))
-        else:
-            print(doc)
-
-    if loader:
-        reg = DataLoaderRotator.list_loaders()
-        match = next((x for x in reg if x["name"].lower() == loader.lower()), None)
-        if match:
-            desc = (match.get("description") or "No description.").strip()
-            if HAS_RICH:
-                echo(Panel(desc, title=f"Loader: {loader}"))
-            else:
-                print(desc)
-        else:
-            typer.echo(f"Unknown loader: {loader}")
-
-    if aggregation:
-        agg = aggs.pick(aggregation)
-        desc = aggs.descriptions().get(agg, "No description.")
-        if HAS_RICH:
-            from rich.panel import Panel
-            echo(Panel(desc, title=f"Aggregation: {aggregation}"))
-        else:
-            print(desc)
-
-
-@app.command("loader-args")
-def loader_args(
-    name: str = typer.Argument(..., help="Loader name, e.g. 'custom'"),
-    loaders_location: Optional[str] = typer.Option(None, help="Where to discover data loaders"),
-):
-    """
-    Show the exact arguments accepted by the loader's `load(...)` method.
-    Useful so users know precisely what to pass (e.g., for `custom`:
-    `path, split_ratio, seed, training_limit, testing_limit`).
-    """
-    from wisent.cli.data_loaders.data_loader_rotator import DataLoaderRotator  # type: ignore
-    if loaders_location:
-        DataLoaderRotator.discover_loaders(loaders_location)
-    rot = DataLoaderRotator(loader=name, loaders_location=loaders_location or "wisent_guard.core.data_loaders.loaders")
-    # Best-effort introspection
-    target = None
-    for cand in (getattr(rot, "_loader", None), rot):
-        if cand is None:
-            continue
-        if hasattr(cand, "load"):
-            target = cand.load
-            break
-    if target is None:
-        typer.echo("Could not introspect loader signature.")
-        raise typer.Exit(code=1)
-
-    sig = inspect.signature(target)
-    if HAS_RICH:
-        from rich.panel import Panel
-        echo(Panel(f"{name}.load{sig}", title="Loader load(...) signature"))
-    else:
-        print(f"{name}.load{sig}")