self-evolve-framework 1.6.0 → 1.6.1

package/template/skills/skillopt-sleep/scripts/framework/skillopt/model/qwen_backend.py

@@ -1,456 +0,0 @@
-"""OpenAI-compatible Qwen chat backend for optimizer and target paths."""
-from __future__ import annotations
-
-from dataclasses import dataclass
-import json
-import os
-import threading
-import time
-import urllib.error
-import urllib.request
-from typing import Any
-
-from skillopt.model.common import (
-    CompatAssistantMessage,
-    CompatToolCall,
-    CompatToolFunction,
-    TokenTracker,
-    default_model_for_backend,
-)
-
-
-@dataclass
-class QwenChatConfig:
-    base_url: str
-    api_key: str
-    timeout_seconds: float
-    max_tokens: int
-    temperature: float | None
-    enable_thinking: bool
-    deployment: str
-
-
-def _parse_bool(value: Any, default: bool = False) -> bool:
-    if value is None:
-        return default
-    return str(value).strip().lower() in {"1", "true", "yes", "on"}
-
-
-def _parse_optional_float(value: Any) -> float | None:
-    if value is None:
-        return None
-    raw = str(value).strip()
-    return float(raw) if raw else None
-
-
-def _parse_int(value: Any, default: int) -> int:
-    if value is None:
-        return default
-    raw = str(value).strip()
-    return int(raw) if raw else default
-
-
-def _role_env(role: str, key: str, default: str) -> str:
-    role_key = f"{role.upper()}_QWEN_CHAT_{key}"
-    generic_key = f"QWEN_CHAT_{key}"
-    return os.environ.get(role_key) or os.environ.get(generic_key) or default
-
-
-def _initial_config(role: str) -> QwenChatConfig:
-    role_upper = role.upper()
-    deployment_env = "OPTIMIZER_DEPLOYMENT" if role == "optimizer" else "TARGET_DEPLOYMENT"
-    return QwenChatConfig(
-        base_url=_role_env(role, "BASE_URL", "http://localhost:8000/v1"),
-        api_key=_role_env(role, "API_KEY", ""),
-        timeout_seconds=float(_role_env(role, "TIMEOUT_SECONDS", "300") or 300),
-        max_tokens=_parse_int(_role_env(role, "MAX_TOKENS", "8000"), 8000),
-        temperature=_parse_optional_float(_role_env(role, "TEMPERATURE", "0.7")),
-        enable_thinking=_parse_bool(_role_env(role, "ENABLE_THINKING", "false")),
-        deployment=(
-            os.environ.get(f"{role_upper}_QWEN_CHAT_MODEL")
-            or os.environ.get("QWEN_CHAT_MODEL")
-            or os.environ.get(deployment_env)
-            or default_model_for_backend("qwen_chat")
-        ),
-    )
-
-
-OPTIMIZER_CONFIG = _initial_config("optimizer")
-TARGET_CONFIG = _initial_config("target")
-
-_config_lock = threading.Lock()
-tracker = TokenTracker()
-
-
-def _chat_url(config: QwenChatConfig) -> str:
-    base = config.base_url.rstrip("/")
-    if base.endswith("/chat/completions"):
-        return base
-    return f"{base}/chat/completions"
-
-
-def _json_safe(value: Any) -> Any:
-    if value is None or isinstance(value, (str, int, float, bool)):
-        return value
-    if isinstance(value, list):
-        return [_json_safe(item) for item in value]
-    if isinstance(value, dict):
-        return {str(key): _json_safe(val) for key, val in value.items()}
-    model_dump = getattr(value, "model_dump", None)
-    if callable(model_dump):
-        try:
-            return model_dump(mode="json")
-        except TypeError:
-            return model_dump()
-    return str(value)
-
-
-def _usage_from_payload(payload: dict[str, Any]) -> dict[str, int]:
-    usage = payload.get("usage") or {}
-    prompt_tokens = int(usage.get("prompt_tokens") or usage.get("input_tokens") or 0)
-    completion_tokens = int(usage.get("completion_tokens") or usage.get("output_tokens") or 0)
-    total_tokens = int(usage.get("total_tokens") or (prompt_tokens + completion_tokens))
-    return {
-        "prompt_tokens": prompt_tokens,
-        "completion_tokens": completion_tokens,
-        "total_tokens": total_tokens,
-    }
-
-
-def _compat_message_from_payload(message: dict[str, Any], choice: dict[str, Any]) -> CompatAssistantMessage:
-    content = message.get("content") or ""
-    if not isinstance(content, str):
-        content = json.dumps(content, ensure_ascii=False)
-    tool_calls: list[CompatToolCall] = []
-    for index, tool_call in enumerate(message.get("tool_calls") or [], start=1):
-        function = tool_call.get("function") or {}
-        tool_calls.append(
-            CompatToolCall(
-                id=str(tool_call.get("id") or f"qwen_tool_{index}"),
-                type=str(tool_call.get("type") or "function"),
-                function=CompatToolFunction(
-                    name=str(function.get("name") or ""),
-                    arguments=str(function.get("arguments") or "{}"),
-                ),
-            )
-        )
-    return CompatAssistantMessage(
-        content=content,
-        tool_calls=tool_calls,
-        metadata={
-            "finish_reason": choice.get("finish_reason"),
-            "choice0": _json_safe(choice),
-        },
-    )
-
-
-def _post_chat_completion(
-    payload: dict[str, Any],
-    timeout: float | None,
-    config: QwenChatConfig,
-) -> dict[str, Any]:
-    headers = {"Content-Type": "application/json"}
-    if config.api_key:
-        headers["Authorization"] = f"Bearer {config.api_key}"
-    req = urllib.request.Request(
-        _chat_url(config),
-        data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
-        headers=headers,
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=timeout or config.timeout_seconds) as resp:
-            raw = resp.read().decode("utf-8")
-    except urllib.error.HTTPError as e:
-        body = e.read().decode("utf-8", errors="replace")
-        raise RuntimeError(f"Qwen chat API returned HTTP {e.code}: {body}") from e
-    except urllib.error.URLError as e:
-        raise RuntimeError(f"Qwen chat API request failed: {e}") from e
-    try:
-        return json.loads(raw)
-    except json.JSONDecodeError as e:
-        raise RuntimeError(f"Qwen chat API returned non-JSON response: {raw[:1000]}") from e
-
-
-def _chat_messages_impl(
-    messages: list[dict[str, Any]],
-    max_completion_tokens: int,
-    retries: int,
-    stage: str,
-    *,
-    role: str,
-    tools: list[dict[str, Any]] | None = None,
-    tool_choice: str | dict[str, Any] | None = None,
-    return_message: bool = False,
-    deployment: str | None = None,
-    timeout: float | None = None,
-) -> tuple[Any, dict[str, int]]:
-    config = OPTIMIZER_CONFIG if role == "optimizer" else TARGET_CONFIG
-    payload: dict[str, Any] = {
-        "model": deployment or config.deployment,
-        "messages": _json_safe(messages),
-        "max_tokens": min(max_completion_tokens, config.max_tokens),
-    }
-    if config.enable_thinking:
-        payload["chat_template_kwargs"] = {"enable_thinking": True}
-    if config.temperature is not None:
-        payload["temperature"] = config.temperature
-    if tools:
-        payload["tools"] = _json_safe(tools)
-        if tool_choice is not None:
-            payload["tool_choice"] = _json_safe(tool_choice)
-
-    last_err: Exception | None = None
-    for attempt in range(retries):
-        try:
-            data = _post_chat_completion(payload, timeout, config)
-            choices = data.get("choices") or []
-            if not choices:
-                raise RuntimeError(f"Qwen chat API returned no choices: {data}")
-            choice0 = choices[0]
-            message = choice0.get("message") or {}
-            text = message.get("content") or ""
-            if not isinstance(text, str):
-                text = json.dumps(text, ensure_ascii=False)
-            usage_info = _usage_from_payload(data)
-            tracker.record(stage, usage_info["prompt_tokens"], usage_info["completion_tokens"])
-            if return_message:
-                return _compat_message_from_payload(message, choice0), usage_info
-            return text, usage_info
-        except Exception as e:  # noqa: BLE001
-            last_err = e
-            time.sleep(min(2 ** attempt, 30))
-    raise RuntimeError(f"Qwen chat call failed after {retries} retries: {last_err}")
-
-
-def configure_qwen_chat(
-    *,
-    base_url: str | None = None,
-    api_key: str | None = None,
-    temperature: float | str | None = None,
-    timeout_seconds: float | str | None = None,
-    max_tokens: int | str | None = None,
-    enable_thinking: bool | str | None = None,
-    optimizer_base_url: str | None = None,
-    optimizer_api_key: str | None = None,
-    optimizer_temperature: float | str | None = None,
-    optimizer_timeout_seconds: float | str | None = None,
-    optimizer_max_tokens: int | str | None = None,
-    optimizer_enable_thinking: bool | str | None = None,
-    target_base_url: str | None = None,
-    target_api_key: str | None = None,
-    target_temperature: float | str | None = None,
-    target_timeout_seconds: float | str | None = None,
-    target_max_tokens: int | str | None = None,
-    target_enable_thinking: bool | str | None = None,
-) -> None:
-    with _config_lock:
-        if base_url is not None:
-            os.environ["QWEN_CHAT_BASE_URL"] = str(base_url).strip()
-        if api_key is not None:
-            os.environ["QWEN_CHAT_API_KEY"] = str(api_key).strip()
-        if temperature is not None:
-            os.environ["QWEN_CHAT_TEMPERATURE"] = str(temperature).strip()
-        if timeout_seconds is not None:
-            os.environ["QWEN_CHAT_TIMEOUT_SECONDS"] = str(timeout_seconds)
-        if max_tokens is not None:
-            os.environ["QWEN_CHAT_MAX_TOKENS"] = str(max_tokens)
-        if enable_thinking is not None:
-            os.environ["QWEN_CHAT_ENABLE_THINKING"] = (
-                "true" if _parse_bool(enable_thinking) else "false"
-            )
-        _update_config(
-            OPTIMIZER_CONFIG,
-            "optimizer",
-            base_url=optimizer_base_url if optimizer_base_url is not None else base_url,
-            api_key=optimizer_api_key if optimizer_api_key is not None else api_key,
-            temperature=(
-                optimizer_temperature
-                if optimizer_temperature is not None
-                else temperature
-            ),
-            timeout_seconds=(
-                optimizer_timeout_seconds
-                if optimizer_timeout_seconds is not None
-                else timeout_seconds
-            ),
-            max_tokens=optimizer_max_tokens if optimizer_max_tokens is not None else max_tokens,
-            enable_thinking=(
-                optimizer_enable_thinking
-                if optimizer_enable_thinking is not None
-                else enable_thinking
-            ),
-        )
-        _update_config(
-            TARGET_CONFIG,
-            "target",
-            base_url=target_base_url if target_base_url is not None else base_url,
-            api_key=target_api_key if target_api_key is not None else api_key,
-            temperature=target_temperature if target_temperature is not None else temperature,
-            timeout_seconds=(
-                target_timeout_seconds
-                if target_timeout_seconds is not None
-                else timeout_seconds
-            ),
-            max_tokens=target_max_tokens if target_max_tokens is not None else max_tokens,
-            enable_thinking=(
-                target_enable_thinking
-                if target_enable_thinking is not None
-                else enable_thinking
-            ),
-        )
-
-
-def _update_config(
-    config: QwenChatConfig,
-    role: str,
-    *,
-    base_url: str | None = None,
-    api_key: str | None = None,
-    temperature: float | str | None = None,
-    timeout_seconds: float | str | None = None,
-    max_tokens: int | str | None = None,
-    enable_thinking: bool | str | None = None,
-) -> None:
-    env_prefix = role.upper()
-    if base_url is not None:
-        config.base_url = str(base_url).strip() or config.base_url
-        os.environ[f"{env_prefix}_QWEN_CHAT_BASE_URL"] = config.base_url
-    if api_key is not None:
-        config.api_key = str(api_key).strip()
-        os.environ[f"{env_prefix}_QWEN_CHAT_API_KEY"] = config.api_key
-    if temperature is not None:
-        raw = str(temperature).strip()
-        config.temperature = float(raw) if raw else None
-        os.environ[f"{env_prefix}_QWEN_CHAT_TEMPERATURE"] = raw
-    if timeout_seconds is not None:
-        config.timeout_seconds = float(timeout_seconds)
-        os.environ[f"{env_prefix}_QWEN_CHAT_TIMEOUT_SECONDS"] = str(timeout_seconds)
-    if max_tokens is not None:
-        config.max_tokens = int(max_tokens)
-        os.environ[f"{env_prefix}_QWEN_CHAT_MAX_TOKENS"] = str(max_tokens)
-    if enable_thinking is not None:
-        config.enable_thinking = _parse_bool(enable_thinking)
-        os.environ[f"{env_prefix}_QWEN_CHAT_ENABLE_THINKING"] = (
-            "true" if config.enable_thinking else "false"
-        )
-
-
-def get_max_tokens() -> int:
-    return TARGET_CONFIG.max_tokens
-
-
-def chat_optimizer(
-    system: str,
-    user: str,
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "optimizer",
-    reasoning_effort: str | None = None,
-    timeout: float | None = None,
-) -> tuple[str, dict[str, int]]:
-    del reasoning_effort
-    messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
-    return _chat_messages_impl(
-        messages,
-        max_completion_tokens,
-        retries,
-        stage,
-        role="optimizer",
-        timeout=timeout,
-    )
-
-
-def chat_target(
-    system: str,
-    user: str,
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "target",
-    reasoning_effort: str | None = None,
-    timeout: float | None = None,
-) -> tuple[str, dict[str, int]]:
-    del reasoning_effort
-    messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
-    return _chat_messages_impl(
-        messages,
-        max_completion_tokens,
-        retries,
-        stage,
-        role="target",
-        timeout=timeout,
-    )
-
-
-def chat_optimizer_messages(
-    messages: list[dict[str, Any]],
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "optimizer",
-    reasoning_effort: str | None = None,
-    *,
-    tools: list[dict[str, Any]] | None = None,
-    tool_choice: str | dict[str, Any] | None = None,
-    return_message: bool = False,
-    timeout: float | None = None,
-) -> tuple[Any, dict[str, int]]:
-    del reasoning_effort
-    return _chat_messages_impl(
-        messages,
-        max_completion_tokens,
-        retries,
-        stage,
-        role="optimizer",
-        tools=tools,
-        tool_choice=tool_choice,
-        return_message=return_message,
-        timeout=timeout,
-    )
-
-
-def chat_target_messages(
-    messages: list[dict[str, Any]],
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "target",
-    reasoning_effort: str | None = None,
-    *,
-    tools: list[dict[str, Any]] | None = None,
-    tool_choice: str | dict[str, Any] | None = None,
-    return_message: bool = False,
-    timeout: float | None = None,
-) -> tuple[Any, dict[str, int]]:
-    del reasoning_effort
-    return _chat_messages_impl(
-        messages,
-        max_completion_tokens,
-        retries,
-        stage,
-        role="target",
-        tools=tools,
-        tool_choice=tool_choice,
-        return_message=return_message,
-        timeout=timeout,
-    )
-
-
-def get_token_summary() -> dict[str, dict[str, int]]:
-    return tracker.summary()
-
-
-def reset_token_tracker() -> None:
-    tracker.reset()
-
-
-def set_reasoning_effort(effort: str | None) -> None:
-    del effort
-
-
-def set_target_deployment(deployment: str) -> None:
-    TARGET_CONFIG.deployment = deployment or default_model_for_backend("qwen_chat")
-    os.environ["TARGET_DEPLOYMENT"] = TARGET_CONFIG.deployment
-
-
-def set_optimizer_deployment(deployment: str) -> None:
-    OPTIMIZER_CONFIG.deployment = deployment or default_model_for_backend("qwen_chat")
-    os.environ["OPTIMIZER_DEPLOYMENT"] = OPTIMIZER_CONFIG.deployment

package/template/skills/skillopt-sleep/scripts/framework/skillopt/model/router.py

@@ -1,236 +0,0 @@
-"""Runtime backend router for ReflACT model calls."""
-from __future__ import annotations
-
-import os
-from typing import Any
-
-from . import azure_openai, claude_backend, codex_backend
-from .common import normalize_backend_name
-
-
-_ACTIVE_BACKEND = normalize_backend_name(
-    os.environ.get("REFLACT_MODEL_BACKEND", "azure_openai")
-)
-
-
-def _backend_module(name: str):
-    if name == "azure_openai":
-        return azure_openai
-    if name == "codex":
-        return codex_backend
-    if name == "claude":
-        return claude_backend
-    raise ValueError(f"Unknown backend: {name!r}")
-
-
-def _all_backend_modules() -> list[Any]:
-    return [azure_openai, codex_backend, claude_backend]
-
-
-def set_backend(name: str | None) -> str:
-    """Select the active model backend for subsequent calls."""
-    global _ACTIVE_BACKEND
-    normalized = normalize_backend_name(name)
-    if normalized not in {"azure_openai", "codex", "claude"}:
-        valid = ", ".join(sorted({"azure_openai", "codex", "claude"}))
-        raise ValueError(f"Unknown backend {name!r}. Expected one of: {valid}")
-    _ACTIVE_BACKEND = normalized
-    os.environ["REFLACT_MODEL_BACKEND"] = normalized
-    return _ACTIVE_BACKEND
-
-
-def get_backend_name() -> str:
-    return _ACTIVE_BACKEND
-
-
-def chat_optimizer(
-    system: str,
-    user: str,
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "optimizer",
-    timeout: int | None = None,
-) -> tuple[str, dict[str, int]]:
-    return _backend_module(_ACTIVE_BACKEND).chat_optimizer(
-        system=system,
-        user=user,
-        max_completion_tokens=max_completion_tokens,
-        retries=retries,
-        stage=stage,
-        timeout=timeout,
-    )
-
-
-def chat_target(
-    system: str,
-    user: str,
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "target",
-    timeout: int | None = None,
-) -> tuple[str, dict[str, int]]:
-    return _backend_module(_ACTIVE_BACKEND).chat_target(
-        system=system,
-        user=user,
-        max_completion_tokens=max_completion_tokens,
-        retries=retries,
-        stage=stage,
-        timeout=timeout,
-    )
-
-
-def chat_with_deployment(
-    deployment: str,
-    system: str,
-    user: str,
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "custom",
-    timeout: int | None = None,
-) -> tuple[str, dict[str, int]]:
-    return _backend_module(_ACTIVE_BACKEND).chat_with_deployment(
-        deployment=deployment,
-        system=system,
-        user=user,
-        max_completion_tokens=max_completion_tokens,
-        retries=retries,
-        stage=stage,
-        timeout=timeout,
-    )
-
-
-def chat_optimizer_messages(
-    messages: list[dict[str, Any]],
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "optimizer",
-    *,
-    tools: list[dict[str, Any]] | None = None,
-    tool_choice: str | dict[str, Any] | None = None,
-    return_message: bool = False,
-    timeout: int | None = None,
-) -> tuple[Any, dict[str, int]]:
-    return _backend_module(_ACTIVE_BACKEND).chat_optimizer_messages(
-        messages=messages,
-        max_completion_tokens=max_completion_tokens,
-        retries=retries,
-        stage=stage,
-        tools=tools,
-        tool_choice=tool_choice,
-        return_message=return_message,
-        timeout=timeout,
-    )
-
-
-def chat_target_messages(
-    messages: list[dict[str, Any]],
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "target",
-    *,
-    tools: list[dict[str, Any]] | None = None,
-    tool_choice: str | dict[str, Any] | None = None,
-    return_message: bool = False,
-    timeout: int | None = None,
-) -> tuple[Any, dict[str, int]]:
-    return _backend_module(_ACTIVE_BACKEND).chat_target_messages(
-        messages=messages,
-        max_completion_tokens=max_completion_tokens,
-        retries=retries,
-        stage=stage,
-        tools=tools,
-        tool_choice=tool_choice,
-        return_message=return_message,
-        timeout=timeout,
-    )
-
-
-def chat_messages_with_deployment(
-    deployment: str,
-    messages: list[dict[str, Any]],
-    max_completion_tokens: int = 16384,
-    retries: int = 5,
-    stage: str = "custom",
-    *,
-    tools: list[dict[str, Any]] | None = None,
-    tool_choice: str | dict[str, Any] | None = None,
-    return_message: bool = False,
-    timeout: int | None = None,
-) -> tuple[Any, dict[str, int]]:
-    return _backend_module(_ACTIVE_BACKEND).chat_messages_with_deployment(
-        deployment=deployment,
-        messages=messages,
-        max_completion_tokens=max_completion_tokens,
-        retries=retries,
-        stage=stage,
-        tools=tools,
-        tool_choice=tool_choice,
-        return_message=return_message,
-        timeout=timeout,
-    )
-
-
-def get_token_summary() -> dict[str, dict[str, int]]:
-    return _backend_module(_ACTIVE_BACKEND).get_token_summary()
-
-
-def reset_token_tracker() -> None:
-    _backend_module(_ACTIVE_BACKEND).reset_token_tracker()
-
-
-def set_reasoning_effort(effort: str | None) -> None:
-    for module in _all_backend_modules():
-        module.set_reasoning_effort(effort)
-
-
-def set_target_deployment(deployment: str) -> None:
-    for module in _all_backend_modules():
-        module.set_target_deployment(deployment)
-
-
-def set_optimizer_deployment(deployment: str) -> None:
-    for module in _all_backend_modules():
-        module.set_optimizer_deployment(deployment)
-
-
-def configure_azure_openai(
-    *,
-    endpoint: str | None = None,
-    api_version: str | None = None,
-    api_key: str | None = None,
-    auth_mode: str | None = None,
-    ad_scope: str | None = None,
-    managed_identity_client_id: str | None = None,
-    optimizer_endpoint: str | None = None,
-    optimizer_api_version: str | None = None,
-    optimizer_api_key: str | None = None,
-    optimizer_auth_mode: str | None = None,
-    optimizer_ad_scope: str | None = None,
-    optimizer_managed_identity_client_id: str | None = None,
-    target_endpoint: str | None = None,
-    target_api_version: str | None = None,
-    target_api_key: str | None = None,
-    target_auth_mode: str | None = None,
-    target_ad_scope: str | None = None,
-    target_managed_identity_client_id: str | None = None,
-) -> None:
-    azure_openai.configure_azure_openai(
-        endpoint=endpoint,
-        api_version=api_version,
-        api_key=api_key,
-        auth_mode=auth_mode,
-        ad_scope=ad_scope,
-        managed_identity_client_id=managed_identity_client_id,
-        optimizer_endpoint=optimizer_endpoint,
-        optimizer_api_version=optimizer_api_version,
-        optimizer_api_key=optimizer_api_key,
-        optimizer_auth_mode=optimizer_auth_mode,
-        optimizer_ad_scope=optimizer_ad_scope,
-        optimizer_managed_identity_client_id=optimizer_managed_identity_client_id,
-        target_endpoint=target_endpoint,
-        target_api_version=target_api_version,
-        target_api_key=target_api_key,
-        target_auth_mode=target_auth_mode,
-        target_ad_scope=target_ad_scope,
-        target_managed_identity_client_id=target_managed_identity_client_id,
-    )

package/template/skills/skillopt-sleep/scripts/framework/skillopt/optimizer/__init__.py

@@ -1,15 +0,0 @@
-"""SkillOpt Optimizer -- skill update operations.
-
-Analogous to the optimizer in neural network training: applies the computed
-"gradient" (patches) to the current skill document to produce an updated
-candidate skill.
-
-Modules
--------
-- skill: edit application (optimizer.step() / parameter update)
-- clip: edit ranking and selection (gradient clipping)
-- slow_update: longitudinal comparison and guidance (EMA / regularization)
-- meta_skill: cross-epoch memory for optimizer context
-"""
-from skillopt.optimizer.skill import apply_edit, apply_patch  # noqa: F401
-from skillopt.optimizer.clip import rank_and_select  # noqa: F401