ag2 0.10.2__py3-none-any.whl

autogen/llm_config/client.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from collections.abc import Sequence
+from typing import Any, Protocol
+
+from ..doc_utils import export_module
+
+
+@export_module("autogen")
+class ModelClient(Protocol):
+    """A client class must implement the following methods:
+    - create must return a response object that implements the ModelClientResponseProtocol
+    - cost must return the cost of the response
+    - get_usage must return a dict with the following keys:
+        - prompt_tokens
+        - completion_tokens
+        - total_tokens
+        - cost
+        - model
+
+    This class is used to create a client that can be used by OpenAIWrapper.
+    The response returned from create must adhere to the ModelClientResponseProtocol but can be extended however needed.
+    The message_retrieval method must be implemented to return a list of str or a list of messages from the response.
+    """
+
+    RESPONSE_USAGE_KEYS: list[str] = ["prompt_tokens", "completion_tokens", "total_tokens", "cost", "model"]
+
+    class ModelClientResponseProtocol(Protocol):
+        class Choice(Protocol):
+            class Message(Protocol):
+                content: str | dict[str, Any] | list[dict[str, Any]] | None
+
+            message: Message
+
+        choices: Sequence[Choice]
+        model: str
+
+    def create(self, params: dict[str, Any]) -> ModelClientResponseProtocol: ...  # pragma: no cover
+
+    def message_retrieval(
+        self, response: ModelClientResponseProtocol
+    ) -> list[str] | list["ModelClient.ModelClientResponseProtocol.Choice.Message"]:
+        """Retrieve and return a list of strings or a list of Choice.Message from the response.
+
+        NOTE: if a list of Choice.Message is returned, it currently needs to contain the fields of OpenAI's ChatCompletion Message object,
+        since that is expected for function or tool calling in the rest of the codebase at the moment, unless a custom agent is being used.
+        """
+        ...  # pragma: no cover
+
+    def cost(self, response: ModelClientResponseProtocol) -> float: ...  # pragma: no cover
+
+    @staticmethod
+    def get_usage(response: ModelClientResponseProtocol) -> dict[str, Any]:
+        """Return usage summary of the response using RESPONSE_USAGE_KEYS."""
+        ...  # pragma: no cover

autogen/llm_config/config.py

@@ -0,0 +1,461 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import functools
+import json
+import re
+import warnings
+from collections.abc import Iterable
+from contextvars import ContextVar
+from pathlib import Path
+from typing import Annotated, Any, Literal, TypeAlias
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Self, deprecated
+
+from autogen.doc_utils import export_module
+
+from .entry import ApplicationConfig, LLMConfigEntry
+from .types import ConfigEntries
+from .utils import config_list_from_json, filter_config
+
+
+# Meta class to allow LLMConfig.current and LLMConfig.default to be used as class properties
+class MetaLLMConfig(type):
+    def __init__(cls, *args: Any, **kwargs: Any) -> None:
+        pass
+
+    @property
+    @deprecated(
+        "`LLMConfig.current / .default` properties are deprecated. "
+        "Pass config object to usage explicitly instead. "
+        "Scheduled for removal in 0.11.0 version."
+    )
+    def current(cls) -> "LLMConfig":
+        current_llm_config = LLMConfig.get_current_llm_config(llm_config=None)
+        if current_llm_config is None:
+            raise ValueError("No current LLMConfig set. Are you inside a context block?")
+        return current_llm_config  # type: ignore[return-value]
+
+    @property
+    @deprecated(
+        "`LLMConfig.current / .default` properties are deprecated. "
+        "Pass config object to usage explicitly instead. "
+        "Scheduled for removal in 0.11.0 version."
+    )
+    def default(cls) -> "LLMConfig":
+        return cls.current
+
+
+ConfigItem: TypeAlias = LLMConfigEntry | ConfigEntries | dict[str, Any]
+
+
+@export_module("autogen")
+class LLMConfig(metaclass=MetaLLMConfig):
+    _current_llm_config: ContextVar["LLMConfig"] = ContextVar("current_llm_config")
+    config_list: list[ConfigEntries]
+
+    def __init__(
+        self,
+        *configs: ConfigItem,
+        top_p: float | None = None,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        check_every_ms: int | None = None,
+        allow_format_str_template: bool | None = None,
+        response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None = None,
+        timeout: int | None = None,
+        seed: int | None = None,
+        cache_seed: int | None = None,
+        parallel_tool_calls: bool | None = None,
+        tools: Iterable[Any] = (),
+        functions: Iterable[Any] = (),
+        routing_method: Literal["fixed_order", "round_robin"] | None = None,
+        config_list: Annotated[
+            Iterable[ConfigItem] | dict[str, Any],
+            deprecated(
+                "`LLMConfig(config_list=[{'model': ..., 'api_key': ...}, ...])` syntax is deprecated. "
+                "Use `LLMConfig({'api_key': ..., 'model': ...}, ...)` instead. "
+                "Scheduled for removal in 0.11.0 version."
+            ),
+        ] = (),
+        **kwargs: Annotated[
+            Any,
+            deprecated(
+                "`LLMConfig(api_key=..., model=...)` syntax is deprecated. "
+                "Use `LLMConfig({'api_key': ..., 'model': ...})` instead. "
+                "Scheduled for removal in 0.11.0 version."
+            ),
+        ],
+    ) -> None:
+        r"""Initializes the LLMConfig object.
+
+        Args:
+            *configs: A list of LLM configuration entries or dictionaries.
+            config_list: A list of LLM configuration entries or dictionaries.
+            temperature: The sampling temperature for LLM generation.
+            check_every_ms: The interval (in milliseconds) to check for updates
+            allow_format_str_template: Whether to allow format string templates.
+            response_format: The format of the response (e.g., JSON, text).
+            timeout: The timeout for LLM requests in seconds.
+            seed: The random seed for reproducible results.
+            cache_seed: The seed for caching LLM responses.
+            parallel_tool_calls: Whether to enable parallel tool calls.
+            tools: A list of tools available for the LLM.
+            functions: A list of functions available for the LLM.
+            max_tokens: The maximum number of tokens to generate.
+            top_p: The nucleus sampling probability.
+            routing_method: The method used to route requests (e.g., fixed_order, round_robin).
+            **kwargs: Additional keyword arguments for\ future extensions.
+
+        Examples:
+            ```python
+            # Example 1: create config from one model dictionary
+            config = LLMConfig({
+                "model": "gpt-5-mini",
+                "api_key": os.environ["OPENAI_API_KEY"],
+            })
+
+            # Example 2: create config from list of dictionaries
+            config = LLMConfig(
+                {
+                    "model": "gpt-5-mini",
+                    "api_key": os.environ["OPENAI_API_KEY"],
+                },
+                {
+                    "model": "gpt-4",
+                    "api_key": os.environ["OPENAI_API_KEY"],
+                },
+            )
+
+            # Example 3 (deprecated): create config from `kwargs` options
+            config = LLMConfig(
+                model="gpt-5-mini",
+                api_key=os.environ["OPENAI_API_KEY"],
+            )
+
+            # Example 4 (deprecated): create config from `config_list` dictionary
+            config = LLMConfig(
+                config_list={
+                    "model": "gpt-5-mini",
+                    "api_key": os.environ["OPENAI_API_KEY"],
+                }
+            )
+
+            # Example 5 (deprecated): create config from `config_list` list
+            config = LLMConfig(
+                config_list=[
+                    {
+                        "model": "gpt-5-mini",
+                        "api_key": os.environ["OPENAI_API_KEY"],
+                    },
+                    {
+                        "model": "gpt-5",
+                        "api_key": os.environ["OPENAI_API_KEY"],
+                    },
+                ]
+            )
+            ```
+        """
+        if isinstance(config_list, dict):
+            config_list = [config_list]
+
+        if kwargs:
+            warnings.warn(
+                (
+                    "`LLMConfig(api_key=..., model=...)` syntax is deprecated. "
+                    "Use `LLMConfig({'api_key': ..., 'model': ...})` instead. "
+                    "Scheduled for removal in 0.11.0 version."
+                ),
+                DeprecationWarning,
+            )
+
+        if config_list:
+            warnings.warn(
+                (
+                    "`LLMConfig(config_list=[{'model': ..., 'api_key': ...}, ...])` syntax is deprecated. "
+                    "Use `LLMConfig({'api_key': ..., 'model': ...}, ...)` instead. "
+                    "Scheduled for removal in 0.11.0 version."
+                ),
+                DeprecationWarning,
+            )
+
+        app_config = ApplicationConfig(
+            max_tokens=max_tokens,
+            top_p=top_p,
+            temperature=temperature,
+        )
+
+        application_level_options = app_config.model_dump(exclude_none=True)
+
+        final_config_list: list[LLMConfigEntry | dict[str, Any]] = []
+        for c in filter(bool, (*configs, *config_list, kwargs)):
+            if isinstance(c, LLMConfigEntry):
+                final_config_list.append(c.apply_application_config(app_config))
+                continue
+
+            else:
+                final_config_list.append({
+                    "api_type": "openai",  # default api_type
+                    **application_level_options,
+                    **c,
+                })
+
+        self._model = _LLMConfig(
+            **application_level_options,
+            config_list=final_config_list,
+            check_every_ms=check_every_ms,
+            seed=seed,
+            allow_format_str_template=allow_format_str_template,
+            response_format=response_format,
+            timeout=timeout,
+            cache_seed=cache_seed,
+            tools=tools or [],
+            functions=functions or [],
+            parallel_tool_calls=parallel_tool_calls,
+            routing_method=routing_method,
+        )
+
+    @classmethod
+    def ensure_config(cls, config: "LLMConfig | ConfigItem | Iterable[ConfigItem]", /) -> "LLMConfig":
+        """Transforms passed objects to LLMConfig object.
+
+        Method to use for `Agent(llm_config={...})` cases.
+
+        >>> LLMConfig.ensure_config(LLMConfig(...))
+        LLMConfig(...)
+
+        >>> LLMConfig.ensure_config(LLMConfigEntry(...))
+        LLMConfig(LLMConfigEntry(...))
+
+        >>> LLMConfig.ensure_config({"model": "gpt-o3"})
+        LLMConfig(OpenAILLMConfigEntry(model="o3"))
+
+        >>> LLMConfig.ensure_config([{"model": "gpt-o3"}, ...])
+        LLMConfig(OpenAILLMConfigEntry(model="o3"), ...)
+
+        >>> (deprecated) LLMConfig.ensure_config({"config_list": [{ "model": "gpt-o3" }, ...]})
+        LLMConfig(OpenAILLMConfigEntry(model="o3"), ...)
+        """
+        if isinstance(config, LLMConfig):
+            return config.copy()
+
+        if isinstance(config, LLMConfigEntry):
+            return LLMConfig(config)
+
+        if isinstance(config, dict):
+            if "config_list" in config:  # backport compatibility
+                return LLMConfig(**config)
+            return LLMConfig(config)
+
+        return LLMConfig(*config)
+
+    @deprecated(
+        "`with llm_config: ...` context manager is deprecated. "
+        "Pass config object to usage explicitly instead. "
+        "Scheduled for removal in 0.11.0 version."
+    )
+    def __enter__(self) -> "LLMConfig":
+        warnings.warn(
+            (
+                "`with llm_config: ...` context manager is deprecated. "
+                "Pass config object to usage explicitly instead. "
+                "Scheduled for removal in 0.11.0 version."
+            ),
+            DeprecationWarning,
+        )
+
+        self._token = LLMConfig._current_llm_config.set(self)
+        return self
+
+    def __exit__(self, exc_type: type[Exception], exc_val: Exception, exc_tb: Any) -> None:
+        LLMConfig._current_llm_config.reset(self._token)
+
+    @classmethod
+    @deprecated(
+        "`LLMConfig.current / .default` properties are deprecated. "
+        "Pass config object to usage explicitly instead. "
+        "Scheduled for removal in 0.11.0 version."
+    )
+    def get_current_llm_config(cls, llm_config: "LLMConfig | None" = None) -> "LLMConfig | None":
+        warnings.warn(
+            (
+                "`LLMConfig.current / .default` properties are deprecated. "
+                "Pass config object to usage explicitly instead. "
+                "Scheduled for removal in 0.11.0 version."
+            ),
+            DeprecationWarning,
+        )
+
+        if llm_config is not None:
+            return llm_config
+        try:
+            return (LLMConfig._current_llm_config.get()).copy()
+        except LookupError:
+            return None
+
+    @classmethod
+    def from_json(
+        cls,
+        *,
+        env: str | None = None,
+        path: str | Path | None = None,
+        file_location: str | None = None,
+        filter_dict: dict[str, list[str | None] | set[str | None]] | None = None,
+        **kwargs: Any,
+    ) -> Self:
+        if env is None and path is None:
+            raise ValueError("Either 'env' or 'path' must be provided")
+
+        if env is not None and path is not None:
+            raise ValueError("Only one of 'env' or 'path' can be provided")
+
+        config_list = config_list_from_json(
+            env_or_file=env if env is not None else str(path),
+            file_location=file_location,
+            filter_dict=filter_dict,
+        )
+
+        return cls(*config_list, **kwargs)
+
+    def where(self, *, exclude: bool = False, **kwargs: Any) -> "LLMConfig":
+        filtered_config_list = filter_config(
+            config_list=[c.model_dump() for c in self.config_list],
+            filter_dict=kwargs,
+            exclude=exclude,
+        )
+
+        if len(filtered_config_list) == 0:
+            raise ValueError(f"No config found that satisfies the filter criteria: {kwargs}")
+
+        kwargs = self.model_dump()
+        del kwargs["config_list"]
+
+        return LLMConfig(*filtered_config_list, **kwargs)
+
+    def model_dump(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> dict[str, Any]:
+        d = self._model.model_dump(*args, exclude_none=exclude_none, **kwargs)
+        return {k: v for k, v in d.items() if not (isinstance(v, list) and len(v) == 0)}
+
+    def model_dump_json(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> str:
+        # return self._model.model_dump_json(*args, exclude_none=exclude_none, **kwargs)
+        d = self.model_dump(*args, exclude_none=exclude_none, **kwargs)
+        return json.dumps(d)
+
+    def model_validate(self, *args: Any, **kwargs: Any) -> Any:
+        return self._model.model_validate(*args, **kwargs)
+
+    @functools.wraps(BaseModel.model_validate_json)
+    def model_validate_json(self, *args: Any, **kwargs: Any) -> Any:
+        return self._model.model_validate_json(*args, **kwargs)
+
+    @functools.wraps(BaseModel.model_validate_strings)
+    def model_validate_strings(self, *args: Any, **kwargs: Any) -> Any:
+        return self._model.model_validate_strings(*args, **kwargs)
+
+    def __eq__(self, value: Any) -> bool:
+        if not isinstance(value, LLMConfig):
+            return NotImplemented
+        return self._model == value._model
+
+    def _getattr(self, o: object, name: str) -> Any:
+        val = getattr(o, name)
+        return val
+
+    def get(self, key: str, default: Any | None = None) -> Any:
+        val = getattr(self._model, key, default)
+        return val
+
+    def __getitem__(self, key: str) -> Any:
+        try:
+            return self._getattr(self._model, key)
+        except AttributeError:
+            raise KeyError(f"Key '{key}' not found in {self.__class__.__name__}")
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        try:
+            setattr(self._model, key, value)
+        except ValueError:
+            raise ValueError(f"'{self.__class__.__name__}' object has no field '{key}'")
+
+    def __getattr__(self, name: Any) -> Any:
+        try:
+            return self._getattr(self._model, name)
+        except AttributeError:
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name == "_model":
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._model, name, value)
+
+    def __contains__(self, key: str) -> bool:
+        return hasattr(self._model, key)
+
+    def __repr__(self) -> str:
+        d = self.model_dump()
+        r = [f"{k}={repr(v)}" for k, v in d.items()]
+
+        s = f"LLMConfig({', '.join(r)})"
+        # Replace any keys ending with 'key' or 'token' values with stars for security
+        s = re.sub(
+            r"(['\"])(\w*(key|token))\1:\s*(['\"])([^'\"]*)(?:\4)", r"\1\2\1: \4**********\4", s, flags=re.IGNORECASE
+        )
+        return s
+
+    def __copy__(self) -> "LLMConfig":
+        options = self._model.model_dump(exclude={"config_list"})
+        return LLMConfig(*self._model.config_list, **options)
+
+    def __deepcopy__(self, memo: dict[int, Any] | None = None) -> "LLMConfig":
+        return self.__copy__()
+
+    def copy(self) -> "LLMConfig":
+        return self.__copy__()
+
+    def deepcopy(self, memo: dict[int, Any] | None = None) -> "LLMConfig":
+        return self.__deepcopy__(memo)
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def items(self) -> Iterable[tuple[str, Any]]:
+        d = self.model_dump()
+        return d.items()
+
+    def keys(self) -> Iterable[str]:
+        d = self.model_dump()
+        return d.keys()
+
+    def values(self) -> Iterable[Any]:
+        d = self.model_dump()
+        return d.values()
+
+    _base_model_classes: dict[tuple[type["LLMConfigEntry"], ...], type[BaseModel]] = {}
+
+
+class _LLMConfig(ApplicationConfig):
+    check_every_ms: int | None
+    seed: int | None
+    allow_format_str_template: bool | None
+    response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None
+    timeout: int | None
+    cache_seed: int | None
+    parallel_tool_calls: bool | None
+
+    tools: list[Any]
+    functions: list[Any]
+
+    config_list: list[
+        Annotated[
+            ConfigEntries,
+            Field(discriminator="api_type"),
+        ],
+    ] = Field(..., min_length=1)
+
+    routing_method: Literal["fixed_order", "round_robin"] | None
+
+    # Following field is configuration for pydantic to disallow extra fields
+    model_config = ConfigDict(extra="forbid")

autogen/llm_config/entry.py

@@ -0,0 +1,169 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import re
+from abc import ABC, abstractmethod
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+from httpx import Client as httpxClient
+from pydantic import BaseModel, ConfigDict, Field, HttpUrl, SecretStr, ValidationInfo, field_serializer, field_validator
+from typing_extensions import Required, Self, TypedDict
+
+from .client import ModelClient
+
+
+class LLMConfigEntryDict(TypedDict, total=False):
+    api_type: Required[str]
+    model: str
+    max_tokens: int | None
+    top_p: float | None
+    temperature: float | None
+
+    api_key: SecretStr | str | None
+    api_version: str | None
+    base_url: HttpUrl | str | None
+    voice: str | None
+    http_client: httpxClient | None
+    model_client_cls: str | None
+    response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None
+    default_headers: Mapping[str, Any] | None
+    tags: list[str]
+
+
+class ApplicationConfig(BaseModel):
+    max_tokens: int | None = Field(
+        default=None,
+        ge=0,
+        description="The maximum number of tokens to generate before stopping.",
+    )
+
+    top_p: float | None = Field(
+        default=None,
+        ge=0,
+        le=1,
+        description=(
+            "An alternative to sampling with temperature, called nucleus sampling, "
+            "where the model considers the results of the tokens with top_p probability mass."
+            "So 0.1 means only the tokens comprising the top 10% probability mass are considered."
+            "You should either alter `temperature` or `top_p`, but not both."
+        ),
+    )
+
+    temperature: float | None = Field(
+        default=None,
+        ge=0,
+        le=1,
+        description=(
+            "Amount of randomness injected into the response. "
+            "Use `temperature` closer to `0.0` for analytical / multiple choice, and closer to a model's "
+            "maximum `temperature` for creative and generative tasks. "
+            "Note that even with `temperature` of `0.0`, the results will not be fully deterministic."
+        ),
+    )
+
+
+class LLMConfigEntry(ApplicationConfig, ABC):
+    api_type: str
+    model: str = Field(..., min_length=1)
+
+    api_key: SecretStr | None = None
+    api_version: str | None = None
+
+    base_url: HttpUrl | None = None
+    http_client: httpxClient | None = None
+
+    voice: str | None = None
+    model_client_cls: str | None = None
+    response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None = None
+    default_headers: Mapping[str, Any] | None = None
+    tags: list[str] = Field(default_factory=list)
+
+    # Following field is configuration for pydantic to disallow extra fields
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+    def apply_application_config(self, application_config: ApplicationConfig) -> Self:
+        """Apply application level configurations."""
+        new_entry = self.model_copy()
+        new_entry.max_tokens = new_entry.max_tokens or application_config.max_tokens
+        new_entry.top_p = new_entry.top_p or application_config.top_p
+        new_entry.temperature = new_entry.temperature or application_config.temperature
+        return new_entry
+
+    @abstractmethod
+    def create_client(self) -> "ModelClient": ...
+
+    @field_validator("base_url", mode="before")
+    @classmethod
+    def check_base_url(cls, v: HttpUrl | str | None, info: ValidationInfo) -> str | None:
+        if v is None:  # Handle None case explicitly
+            return None
+        # Allow WebSocket URLs as well as HTTP(S)
+        if not str(v).startswith(("https://", "http://", "wss://", "ws://")):
+            return f"http://{str(v)}"
+        return str(v)
+
+    @field_serializer("base_url", when_used="unless-none")  # Ensure serializer also respects None
+    def serialize_base_url(self, v: HttpUrl | None) -> str | None:
+        return str(v) if v is not None else None
+
+    @field_serializer("api_key", when_used="unless-none")
+    def serialize_api_key(self, v: SecretStr) -> str:
+        return v.get_secret_value()
+
+    def model_dump(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> dict[str, Any]:
+        return BaseModel.model_dump(self, exclude_none=exclude_none, *args, **kwargs)
+
+    def model_dump_json(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> str:
+        return BaseModel.model_dump_json(self, exclude_none=exclude_none, *args, **kwargs)
+
+    def get(self, key: str, default: Any | None = None) -> Any:
+        val = getattr(self, key, default)
+        if isinstance(val, SecretStr):
+            return val.get_secret_value()
+        return val
+
+    def __getitem__(self, key: str) -> Any:
+        try:
+            val = getattr(self, key)
+            if isinstance(val, SecretStr):
+                return val.get_secret_value()
+            return val
+        except AttributeError:
+            raise KeyError(f"Key '{key}' not found in {self.__class__.__name__}")
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        setattr(self, key, value)
+
+    def __contains__(self, key: str) -> bool:
+        return hasattr(self, key)
+
+    def items(self) -> Iterable[tuple[str, Any]]:
+        d = self.model_dump()
+        return d.items()
+
+    def keys(self) -> Iterable[str]:
+        d = self.model_dump()
+        return d.keys()
+
+    def values(self) -> Iterable[Any]:
+        d = self.model_dump()
+        return d.values()
+
+    def __repr__(self) -> str:
+        # Override to eliminate none values from the repr
+        d = self.model_dump()
+        r = [f"{k}={repr(v)}" for k, v in d.items()]
+
+        s = f"{self.__class__.__name__}({', '.join(r)})"
+
+        # Replace any keys ending with '_key' or '_token' values with stars for security
+        # This regex will match any key ending with '_key' or '_token' and its value, and replace the value with stars
+        # It also captures the type of quote used (single or double) and reuses it in the replacement
+        s = re.sub(r'(\w+_(key|token)\s*=\s*)([\'"]).*?\3', r"\1\3**********\3", s, flags=re.IGNORECASE)
+
+        return s
+
+    def __str__(self) -> str:
+        return repr(self)