camel-ai 0.2.37__py3-none-any.whl → 0.2.39__py3-none-any.whl

camel/memories/context_creators/score_based.py

@@ -11,7 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from pydantic import BaseModel
 
@@ -19,6 +19,7 @@ from camel.logger import get_logger
 from camel.memories.base import BaseContextCreator
 from camel.memories.records import ContextRecord
 from camel.messages import OpenAIMessage
+from camel.types.enums import OpenAIBackendRole
 from camel.utils import BaseTokenCounter
 
 logger = get_logger(__name__)
@@ -64,96 +65,226 @@ class ScoreBasedContextCreator(BaseContextCreator):
         self,
         records: List[ContextRecord],
     ) -> Tuple[List[OpenAIMessage], int]:
-        r"""Creates conversational context from chat history while respecting
+        r"""Constructs conversation context from chat history while respecting
         token limits.
 
-        Constructs the context from provided records and ensures that the total
-        token count does not exceed the specified limit by pruning the least
-        score messages if necessary.
+        Key strategies:
+        1. System message is always prioritized and preserved
+        2. Truncation removes low-score messages first
+        3. Final output maintains chronological order and in history memory,
+           the score of each message decreases according to keep_rate. The
+           newer the message, the higher the score.
 
         Args:
-            records (List[ContextRecord]): A list of message records from which
-                to generate the context.
+            records (List[ContextRecord]): List of context records with scores
+                and timestamps.
 
         Returns:
-            Tuple[List[OpenAIMessage], int]: A tuple containing the constructed
-                context in OpenAIMessage format and the total token count.
+            Tuple[List[OpenAIMessage], int]:
+            - Ordered list of OpenAI messages
+            - Total token count of the final context
 
         Raises:
-            RuntimeError: If it's impossible to create a valid context without
-                exceeding the token limit.
+            RuntimeError: If system message alone exceeds token limit
         """
-        # Create unique context units list
-        uuid_set = set()
-        context_units = []
+        # ======================
+        # 1. System Message Handling
+        # ======================
+        system_unit, regular_units = self._extract_system_message(records)
+        system_tokens = system_unit.num_tokens if system_unit else 0
+
+        # Check early if system message alone exceeds token limit
+        if system_tokens > self.token_limit:
+            raise RuntimeError(
+                f"System message alone exceeds token limit"
+                f": {system_tokens} > {self.token_limit}",
+                system_tokens,
+            )
+
+        # ======================
+        # 2. Deduplication & Initial Processing
+        # ======================
+        seen_uuids = set()
+        if system_unit:
+            seen_uuids.add(system_unit.record.memory_record.uuid)
+
+        # Process non-system messages with deduplication
         for idx, record in enumerate(records):
-            if record.memory_record.uuid not in uuid_set:
-                uuid_set.add(record.memory_record.uuid)
-                context_units.append(
-                    _ContextUnit(
-                        idx=idx,
-                        record=record,
-                        num_tokens=self.token_counter.count_tokens_from_messages(
-                            [record.memory_record.to_openai_message()]
-                        ),
-                    )
+            if record.memory_record.uuid in seen_uuids:
+                continue
+            seen_uuids.add(record.memory_record.uuid)
+
+            token_count = self.token_counter.count_tokens_from_messages(
+                [record.memory_record.to_openai_message()]
+            )
+            regular_units.append(
+                _ContextUnit(
+                    idx=idx,
+                    record=record,
+                    num_tokens=token_count,
                 )
+            )
 
-        # TODO: optimize the process, may give information back to memory
+        # ======================
+        # 3. Token Calculation
+        # ======================
+        total_tokens = system_tokens + sum(u.num_tokens for u in regular_units)
 
-        # If not exceed token limit, simply return
-        total_tokens = sum([unit.num_tokens for unit in context_units])
+        # ======================
+        # 4. Early Return if Within Limit
+        # ======================
         if total_tokens <= self.token_limit:
-            context_units = sorted(
-                context_units,
-                key=lambda unit: (unit.record.timestamp, unit.record.score),
+            sorted_units = sorted(
+                regular_units, key=self._conversation_sort_key
             )
-            return self._create_output(context_units)
+            return self._assemble_output(sorted_units, system_unit)
 
-        # Log warning about token limit being exceeded
+        # ======================
+        # 5. Truncation Logic
+        # ======================
         logger.warning(
-            f"Token limit reached ({total_tokens} > {self.token_limit}). "
-            f"Some messages will be pruned from memory to meet the limit."
+            f"Context truncation required "
+            f"({total_tokens} > {self.token_limit}), "
+            f"pruning low-score messages."
         )
 
-        # Sort by score
-        context_units = sorted(
-            context_units,
-            key=lambda unit: (unit.record.timestamp, unit.record.score),
+        # Sort for truncation: high scores first, older messages first at same
+        # score
+        sorted_for_truncation = sorted(
+            regular_units, key=self._truncation_sort_key
         )
 
-        # Remove the least score messages until total token number is smaller
-        # than token limit
-        truncate_idx = None
-        for i, unit in enumerate(context_units):
-            if i == len(context_units) - 1:
-                # If we reach the end of the list and still exceed the token
-                raise RuntimeError(
-                    "Cannot create context: exceed token limit.", total_tokens
-                )
-            total_tokens -= unit.num_tokens
-            if total_tokens <= self.token_limit:
-                truncate_idx = i
-                break
-        if truncate_idx is None:
+        # Reverse to process from lowest score (end of sorted list)
+        remaining_units = []
+        current_total = system_tokens
+
+        for unit in sorted_for_truncation:
+            potential_total = current_total + unit.num_tokens
+            if potential_total <= self.token_limit:
+                remaining_units.append(unit)
+                current_total = potential_total
+
+        # ======================
+        # 6. Output Assembly
+        # ======================
+
+        # In case system message is the only message in memory when sorted
+        # units are empty, raise an error
+        if system_unit and len(remaining_units) == 0 and len(records) > 1:
             raise RuntimeError(
-                "Cannot create context: exceed token limit.", total_tokens
+                "System message and current message exceeds token limit ",
+                total_tokens,
             )
-        return self._create_output(context_units[truncate_idx + 1 :])
 
-    def _create_output(
-        self, context_units: List[_ContextUnit]
-    ) -> Tuple[List[OpenAIMessage], int]:
-        r"""Helper method to generate output from context units.
+        # Sort remaining units chronologically
+        final_units = sorted(remaining_units, key=self._conversation_sort_key)
+        return self._assemble_output(final_units, system_unit)
+
+    def _extract_system_message(
+        self, records: List[ContextRecord]
+    ) -> Tuple[Optional[_ContextUnit], List[_ContextUnit]]:
+        r"""Extracts the system message from records and validates it.
+
+        Args:
+            records (List[ContextRecord]): List of context records
+                representing conversation history.
 
-        This method converts the provided context units into a format suitable
-        for output, specifically a list of OpenAIMessages and an integer
-        representing the total token count.
+        Returns:
+            Tuple[Optional[_ContextUnit], List[_ContextUnit]]: containing:
+            - The system message as a `_ContextUnit`, if valid; otherwise,
+                `None`.
+            - An empty list, serving as the initial container for regular
+                messages.
         """
-        context_units = sorted(
-            context_units, key=lambda unit: unit.record.timestamp
+        if not records:
+            return None, []
+
+        first_record = records[0]
+        if (
+            first_record.memory_record.role_at_backend
+            != OpenAIBackendRole.SYSTEM
+        ):
+            return None, []
+
+        message = first_record.memory_record.to_openai_message()
+        tokens = self.token_counter.count_tokens_from_messages([message])
+        system_message_unit = _ContextUnit(
+            idx=0,
+            record=first_record,
+            num_tokens=tokens,
         )
-        return [
-            unit.record.memory_record.to_openai_message()
-            for unit in context_units
-        ], sum([unit.num_tokens for unit in context_units])
+        return system_message_unit, []
+
+    def _truncation_sort_key(self, unit: _ContextUnit) -> Tuple[float, float]:
+        r"""Defines the sorting key for the truncation phase.
+
+        Sorting priority:
+        - Primary: Sort by score in descending order (higher scores first).
+        - Secondary: Sort by timestamp in ascending order (older messages
+            first when scores are equal).
+
+        Args:
+            unit (_ContextUnit): A `_ContextUnit` representing a conversation
+                record.
+
+        Returns:
+            Tuple[float, float]:
+            - Negative score for descending order sorting.
+            - Timestamp for ascending order sorting.
+        """
+        return (-unit.record.score, unit.record.timestamp)
+
+    def _conversation_sort_key(
+        self, unit: _ContextUnit
+    ) -> Tuple[float, float]:
+        r"""Defines the sorting key for assembling the final output.
+
+        Sorting priority:
+        - Primary: Sort by timestamp in ascending order (chronological order).
+        - Secondary: Sort by score in descending order (higher scores first
+            when timestamps are equal).
+
+        Args:
+            unit (_ContextUnit): A `_ContextUnit` representing a conversation
+                record.
+
+        Returns:
+            Tuple[float, float]:
+            - Timestamp for chronological sorting.
+            - Negative score for descending order sorting.
+        """
+        return (unit.record.timestamp, -unit.record.score)
+
+    def _assemble_output(
+        self,
+        context_units: List[_ContextUnit],
+        system_unit: Optional[_ContextUnit],
+    ) -> Tuple[List[OpenAIMessage], int]:
+        r"""Assembles final message list with proper ordering and token count.
+
+        Args:
+            context_units (List[_ContextUnit]): Sorted list of regular message
+                units.
+            system_unit (Optional[_ContextUnit]): System message unit (if
+                present).
+
+        Returns:
+            Tuple[List[OpenAIMessage], int]: Tuple of (ordered messages, total
+                tokens)
+        """
+        messages = []
+        total_tokens = 0
+
+        # Add system message first if present
+        if system_unit:
+            messages.append(
+                system_unit.record.memory_record.to_openai_message()
+            )
+            total_tokens += system_unit.num_tokens
+
+        # Add sorted regular messages
+        for unit in context_units:
+            messages.append(unit.record.memory_record.to_openai_message())
+            total_tokens += unit.num_tokens
+
+        return messages, total_tokens

camel/models/__init__.py

@@ -26,6 +26,7 @@ from .litellm_model import LiteLLMModel
 from .mistral_model import MistralModel
 from .model_factory import ModelFactory
 from .model_manager import ModelManager, ModelProcessingError
+from .modelscope_model import ModelScopeModel
 from .moonshot_model import MoonshotModel
 from .nemotron_model import NemotronModel
 from .nvidia_model import NvidiaModel
@@ -77,6 +78,7 @@ __all__ = [
     'DeepSeekModel',
     'FishAudioModel',
     'InternLMModel',
+    'ModelScopeModel',
     'MoonshotModel',
     'AIMLModel',
     'BaseAudioModel',

camel/models/aiml_model.py

@@ -52,6 +52,10 @@ class AIMLModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required([("api_key", "AIML_API_KEY")])
@@ -62,6 +66,7 @@ class AIMLModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = AIMLConfig().as_dict()
@@ -70,17 +75,18 @@ class AIMLModel(BaseModelBackend):
             "AIML_API_BASE_URL",
             "https://api.aimlapi.com/v1",
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/anthropic_model.py

@@ -45,6 +45,10 @@ class AnthropicModel(BaseModelBackend):
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`AnthropicTokenCounter`
             will be used. (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -60,6 +64,7 @@ class AnthropicModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         from openai import AsyncOpenAI, OpenAI
 
@@ -71,13 +76,16 @@ class AnthropicModel(BaseModelBackend):
             or os.environ.get("ANTHROPIC_API_BASE_URL")
             or "https://api.anthropic.com/v1/"
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
+        )
+        self.client = OpenAI(
+            base_url=self._url, api_key=self._api_key, timeout=self._timeout
         )
-        self.client = OpenAI(base_url=self._url, api_key=self._api_key)
 
         self.async_client = AsyncOpenAI(
-            api_key=self._api_key, base_url=self._url
+            api_key=self._api_key, base_url=self._url, timeout=self._timeout
         )
 
     @property

camel/models/azure_openai_model.py

@@ -49,6 +49,10 @@ class AzureOpenAIModel(BaseModelBackend):
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`OpenAITokenCounter`
             will be used. (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
 
     References:
         https://learn.microsoft.com/en-us/azure/ai-services/openai/
@@ -60,6 +64,7 @@ class AzureOpenAIModel(BaseModelBackend):
         model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        timeout: Optional[float] = None,
         token_counter: Optional[BaseTokenCounter] = None,
         api_version: Optional[str] = None,
         azure_deployment_name: Optional[str] = None,
@@ -68,8 +73,9 @@ class AzureOpenAIModel(BaseModelBackend):
             model_config_dict = ChatGPTConfig().as_dict()
         api_key = api_key or os.environ.get("AZURE_OPENAI_API_KEY")
         url = url or os.environ.get("AZURE_OPENAI_BASE_URL")
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
 
         self.api_version = api_version or os.environ.get("AZURE_API_VERSION")
@@ -92,7 +98,7 @@ class AzureOpenAIModel(BaseModelBackend):
             azure_deployment=self.azure_deployment_name,
             api_version=self.api_version,
             api_key=self._api_key,
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
         )
 
@@ -101,7 +107,7 @@ class AzureOpenAIModel(BaseModelBackend):
             azure_deployment=self.azure_deployment_name,
             api_version=self.api_version,
             api_key=self._api_key,
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
         )
 

camel/models/base_audio_model.py

@@ -26,6 +26,7 @@ class BaseAudioModel(ABC):
         self,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         r"""Initialize an instance of BaseAudioModel.
 
@@ -36,9 +37,14 @@ class BaseAudioModel(ABC):
             url (Optional[str]): Base URL for the audio API. If not provided,
                 will use a default URL or look for an environment variable
                 specific to the implementation.
+            timeout (Optional[float], optional): The timeout value in seconds
+                for API calls. If not provided, will fall back to the
+                MODEL_TIMEOUT environment variable or default to 180 seconds.
+                (default: :obj:`None`)
         """
         self._api_key = api_key
         self._url = url
+        self._timeout = timeout
 
     @abstractmethod
     def text_to_speech(

camel/models/base_model.py

@@ -69,6 +69,8 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         token_counter (Optional[BaseTokenCounter], optional): Token
             counter to use for the model. If not provided,
             :obj:`OpenAITokenCounter` will be used. (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. (default: :obj:`None`)
     """
 
     def __init__(
@@ -78,6 +80,7 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         self.model_type: UnifiedModelType = UnifiedModelType(model_type)
         if model_config_dict is None:
@@ -86,6 +89,7 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         self._api_key = api_key
         self._url = url
         self._token_counter = token_counter
+        self._timeout = timeout
         self.check_model_config()
 
     @property

camel/models/deepseek_model.py

@@ -60,6 +60,10 @@ class DeepSeekModel(BaseModelBackend):
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`OpenAITokenCounter`
             will be used. (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
 
     References:
         https://api-docs.deepseek.com/
@@ -77,6 +81,7 @@ class DeepSeekModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = DeepSeekConfig().as_dict()
@@ -85,19 +90,20 @@ class DeepSeekModel(BaseModelBackend):
             "DEEPSEEK_API_BASE_URL",
             "https://api.deepseek.com",
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
 
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
 
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/gemini_model.py

@@ -51,6 +51,10 @@ class GeminiModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -65,6 +69,7 @@ class GeminiModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = GeminiConfig().as_dict()
@@ -73,17 +78,18 @@ class GeminiModel(BaseModelBackend):
             "GEMINI_API_BASE_URL",
             "https://generativelanguage.googleapis.com/v1beta/openai/",
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/groq_model.py

@@ -51,6 +51,10 @@ class GroqModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required([("api_key", "GROQ_API_KEY")])
@@ -61,6 +65,7 @@ class GroqModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = GroqConfig().as_dict()
@@ -68,17 +73,18 @@ class GroqModel(BaseModelBackend):
         url = url or os.environ.get(
             "GROQ_API_BASE_URL", "https://api.groq.com/openai/v1"
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/internlm_model.py

@@ -51,6 +51,10 @@ class InternLMModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -65,6 +69,7 @@ class InternLMModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = InternLMConfig().as_dict()
@@ -73,11 +78,12 @@ class InternLMModel(BaseModelBackend):
             "INTERNLM_API_BASE_URL",
             "https://internlm-chat.intern-ai.org.cn/puyu/api/v1",
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,