edsl 0.1.31__py3-none-any.whl → 0.1.31.dev2__py3-none-any.whl

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.31"
+__version__ = "0.1.31.dev2"

edsl/agents/Invigilator.py

@@ -18,12 +18,7 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
     """An invigilator that uses an AI model to answer questions."""
 
     async def async_answer_question(self) -> AgentResponseDict:
-        """Answer a question using the AI model.
-
-        >>> i = InvigilatorAI.example()
-        >>> i.answer_question()
-        {'message': '{"answer": "SPAM!"}'}
-        """
+        """Answer a question using the AI model."""
         params = self.get_prompts() | {"iteration": self.iteration}
         raw_response = await self.async_get_response(**params)
         data = {
@@ -34,7 +29,6 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
             "raw_model_response": raw_response["raw_model_response"],
         }
         response = self._format_raw_response(**data)
-        # breakpoint()
         return AgentResponseDict(**response)
 
     async def async_get_response(
@@ -103,6 +97,7 @@ class InvigilatorAI(PromptConstructorMixin, InvigilatorBase):
         answer = question._translate_answer_code_to_answer(
             response["answer"], combined_dict
         )
+        # breakpoint()
         data = {
             "answer": answer,
             "comment": response.get(

edsl/agents/PromptConstructionMixin.py

@@ -281,17 +281,12 @@ class PromptConstructorMixin:
             if "question_options" in question_data:
                 if isinstance(self.question.data["question_options"], str):
                     from jinja2 import Environment, meta
-
                     env = Environment()
-                    parsed_content = env.parse(self.question.data["question_options"])
-                    question_option_key = list(
-                        meta.find_undeclared_variables(parsed_content)
-                    )[0]
-                    question_data["question_options"] = self.scenario.get(
-                        question_option_key
-                    )
+                    parsed_content = env.parse(self.question.data['question_options'])
+                    question_option_key = list(meta.find_undeclared_variables(parsed_content))[0]
+                    question_data["question_options"] = self.scenario.get(question_option_key)   
 
-            # breakpoint()
+            #breakpoint()        
             rendered_instructions = question_prompt.render(
                 question_data | self.scenario | d | {"agent": self.agent}
             )

edsl/config.py

@@ -65,10 +65,6 @@ CONFIG_MAP = {
     #     "default": None,
     #     "info": "This env var holds your Anthropic API key (https://www.anthropic.com/).",
     # },
-    # "GROQ_API_KEY": {
-    #     "default": None,
-    #     "info": "This env var holds your GROQ API key (https://console.groq.com/login).",
-    # },
 }
 
 

edsl/conjure/Conjure.py

@@ -35,12 +35,6 @@ class Conjure:
         # The __init__ method in Conjure won't be called because __new__ returns a different class instance.
         pass
 
-    @classmethod
-    def example(cls):
-        from edsl.conjure.InputData import InputDataABC
-
-        return InputDataABC.example()
-
 
 if __name__ == "__main__":
     pass

edsl/coop/coop.py

@@ -465,7 +465,6 @@ class Coop:
         description: Optional[str] = None,
         status: RemoteJobStatus = "queued",
         visibility: Optional[VisibilityType] = "unlisted",
-        iterations: Optional[int] = 1,
     ) -> dict:
         """
         Send a remote inference job to the server.
@@ -474,7 +473,6 @@ class Coop:
         :param optional description: A description for this entry in the remote cache.
         :param status: The status of the job. Should be 'queued', unless you are debugging.
         :param visibility: The visibility of the cache entry.
-        :param iterations: The number of times to run each interview.
 
         >>> job = Jobs.example()
         >>> coop.remote_inference_create(job=job, description="My job")
@@ -490,7 +488,6 @@ class Coop:
                 ),
                 "description": description,
                 "status": status,
-                "iterations": iterations,
                 "visibility": visibility,
                 "version": self._edsl_version,
             },
@@ -501,7 +498,6 @@ class Coop:
             "uuid": response_json.get("jobs_uuid"),
             "description": response_json.get("description"),
             "status": response_json.get("status"),
-            "iterations": response_json.get("iterations"),
             "visibility": response_json.get("visibility"),
             "version": self._edsl_version,
         }

edsl/data/CacheHandler.py

@@ -41,7 +41,7 @@ class CacheHandler:
         old_data = self.from_old_sqlite_cache()
         self.cache.add_from_dict(old_data)
 
-    def create_cache_directory(self, notify = False) -> None:
+    def create_cache_directory(self) -> None:
         """
         Create the cache directory if one is required and it does not exist.
         """
@@ -49,8 +49,9 @@ class CacheHandler:
         dir_path = os.path.dirname(path)
         if dir_path and not os.path.exists(dir_path):
             os.makedirs(dir_path)
-            if notify:
-                print(f"Created cache directory: {dir_path}")
+            import warnings
+
+            warnings.warn(f"Created cache directory: {dir_path}")
 
     def gen_cache(self) -> Cache:
         """

edsl/enums.py

@@ -59,7 +59,6 @@ class InferenceServiceType(EnumWithChecks):
     GOOGLE = "google"
     TEST = "test"
     ANTHROPIC = "anthropic"
-    GROQ = "groq"
 
 
 service_to_api_keyname = {
@@ -70,7 +69,6 @@ service_to_api_keyname = {
     InferenceServiceType.GOOGLE.value: "GOOGLE_API_KEY",
     InferenceServiceType.TEST.value: "TBD",
     InferenceServiceType.ANTHROPIC.value: "ANTHROPIC_API_KEY",
-    InferenceServiceType.GROQ.value: "GROQ_API_KEY",
 }
 
 

edsl/inference_services/DeepInfraService.py

@@ -2,17 +2,102 @@ import aiohttp
 import json
 import requests
 from typing import Any, List
-
-# from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
+from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
 from edsl.language_models import LanguageModel
 
-from edsl.inference_services.OpenAIService import OpenAIService
-
 
-class DeepInfraService(OpenAIService):
+class DeepInfraService(InferenceServiceABC):
     """DeepInfra service class."""
 
     _inference_service_ = "deep_infra"
     _env_key_name_ = "DEEP_INFRA_API_KEY"
-    _base_url_ = "https://api.deepinfra.com/v1/openai"
+
     _models_list_cache: List[str] = []
+
+    @classmethod
+    def available(cls):
+        text_models = cls.full_details_available()
+        return [m["model_name"] for m in text_models]
+
+    @classmethod
+    def full_details_available(cls, verbose=False):
+        if not cls._models_list_cache:
+            url = "https://api.deepinfra.com/models/list"
+            response = requests.get(url)
+            if response.status_code == 200:
+                text_generation_models = [
+                    r for r in response.json() if r["type"] == "text-generation"
+                ]
+                cls._models_list_cache = text_generation_models
+
+                from rich import print_json
+                import json
+
+                if verbose:
+                    print_json(json.dumps(text_generation_models))
+                return text_generation_models
+            else:
+                return f"Failed to fetch data: Status code {response.status_code}"
+        else:
+            return cls._models_list_cache
+
+    @classmethod
+    def create_model(cls, model_name: str, model_class_name=None) -> LanguageModel:
+        base_url = "https://api.deepinfra.com/v1/inference/"
+        if model_class_name is None:
+            model_class_name = cls.to_class_name(model_name)
+        url = f"{base_url}{model_name}"
+
+        class LLM(LanguageModel):
+            _inference_service_ = cls._inference_service_
+            _model_ = model_name
+            _parameters_ = {
+                "temperature": 0.7,
+                "top_p": 0.2,
+                "top_k": 0.1,
+                "max_new_tokens": 512,
+                "stopSequences": [],
+            }
+
+            async def async_execute_model_call(
+                self, user_prompt: str, system_prompt: str = ""
+            ) -> dict[str, Any]:
+                self.url = url
+                headers = {
+                    "Content-Type": "application/json",
+                    "Authorization": f"bearer {self.api_token}",
+                }
+                # don't mess w/ the newlines
+                data = {
+                    "input": f"""
+                    [INST]<<SYS>>
+                    {system_prompt}
+                    <<SYS>>{user_prompt}[/INST]
+                    """,
+                    "stream": False,
+                    "temperature": self.temperature,
+                    "top_p": self.top_p,
+                    "top_k": self.top_k,
+                    "max_new_tokens": self.max_new_tokens,
+                }
+                async with aiohttp.ClientSession() as session:
+                    async with session.post(
+                        self.url, headers=headers, data=json.dumps(data)
+                    ) as response:
+                        raw_response_text = await response.text()
+                        return json.loads(raw_response_text)
+
+            def parse_response(self, raw_response: dict[str, Any]) -> str:
+                if "results" not in raw_response:
+                    raise Exception(
+                        f"Deep Infra response does not contain 'results' key: {raw_response}"
+                    )
+                if "generated_text" not in raw_response["results"][0]:
+                    raise Exception(
+                        f"Deep Infra response does not contain 'generate_text' key: {raw_response['results'][0]}"
+                    )
+                return raw_response["results"][0]["generated_text"]
+
+        LLM.__name__ = model_class_name
+
+        return LLM

edsl/inference_services/InferenceServicesCollection.py

@@ -15,19 +15,18 @@ class InferenceServicesCollection:
         cls.added_models[service_name].append(model_name)
 
     @staticmethod
-    def _get_service_available(service, warn: bool = False) -> list[str]:
+    def _get_service_available(service) -> list[str]:
         from_api = True
         try:
             service_models = service.available()
         except Exception as e:
-            if warn:
-                warnings.warn(
-                    f"""Error getting models for {service._inference_service_}. 
-                    Check that you have properly stored your Expected Parrot API key and activated remote inference, or stored your own API keys for the language models that you want to use.
-                    See https://docs.expectedparrot.com/en/latest/api_keys.html for instructions on storing API keys.
-                    Relying on cache.""",
-                    UserWarning,
-                )
+            warnings.warn(
+                f"""Error getting models for {service._inference_service_}. 
+                Check that you have properly stored your Expected Parrot API key and activated remote inference, or stored your own API keys for the language models that you want to use.
+                See https://docs.expectedparrot.com/en/latest/api_keys.html for instructions on storing API keys.
+                Relying on cache.""",
+                UserWarning,
+            )
             from edsl.inference_services.models_available_cache import models_available
 
             service_models = models_available.get(service._inference_service_, [])
@@ -61,8 +60,4 @@ class InferenceServicesCollection:
                 if service_name is None or service_name == service._inference_service_:
                     return service.create_model(model_name)
 
-        # if model_name == "test":
-        #     from edsl.language_models import LanguageModel
-        #     return LanguageModel(test = True)
-
         raise Exception(f"Model {model_name} not found in any of the services")

edsl/inference_services/OpenAIService.py

@@ -1,9 +1,6 @@
 from typing import Any, List
 import re
-import os
-
-# from openai import AsyncOpenAI
-import openai
+from openai import AsyncOpenAI
 
 from edsl.inference_services.InferenceServiceABC import InferenceServiceABC
 from edsl.language_models import LanguageModel
@@ -15,22 +12,6 @@ class OpenAIService(InferenceServiceABC):
 
     _inference_service_ = "openai"
     _env_key_name_ = "OPENAI_API_KEY"
-    _base_url_ = None
-
-    _sync_client_ = openai.OpenAI
-    _async_client_ = openai.AsyncOpenAI
-
-    @classmethod
-    def sync_client(cls):
-        return cls._sync_client_(
-            api_key=os.getenv(cls._env_key_name_), base_url=cls._base_url_
-        )
-
-    @classmethod
-    def async_client(cls):
-        return cls._async_client_(
-            api_key=os.getenv(cls._env_key_name_), base_url=cls._base_url_
-        )
 
     # TODO: Make this a coop call
     model_exclude_list = [
@@ -50,24 +31,16 @@ class OpenAIService(InferenceServiceABC):
     ]
     _models_list_cache: List[str] = []
 
-    @classmethod
-    def get_model_list(cls):
-        raw_list = cls.sync_client().models.list()
-        if hasattr(raw_list, "data"):
-            return raw_list.data
-        else:
-            return raw_list
-
     @classmethod
     def available(cls) -> List[str]:
-        # from openai import OpenAI
+        from openai import OpenAI
 
         if not cls._models_list_cache:
             try:
-                # client = OpenAI(api_key = os.getenv(cls._env_key_name_), base_url = cls._base_url_)
+                client = OpenAI()
                 cls._models_list_cache = [
                     m.id
-                    for m in cls.get_model_list()
+                    for m in client.models.list()
                     if m.id not in cls.model_exclude_list
                 ]
             except Exception as e:
@@ -105,24 +78,15 @@ class OpenAIService(InferenceServiceABC):
                 "top_logprobs": 3,
             }
 
-            def sync_client(self):
-                return cls.sync_client()
-
-            def async_client(self):
-                return cls.async_client()
-
             @classmethod
             def available(cls) -> list[str]:
-                # import openai
-                # client = openai.OpenAI(api_key = os.getenv(cls._env_key_name_), base_url = cls._base_url_)
-                # return client.models.list()
-                return cls.sync_client().models.list()
+                client = openai.OpenAI()
+                return client.models.list()
 
             def get_headers(self) -> dict[str, Any]:
-                # from openai import OpenAI
+                from openai import OpenAI
 
-                # client = OpenAI(api_key = os.getenv(cls._env_key_name_), base_url = cls._base_url_)
-                client = self.sync_client()
+                client = OpenAI()
                 response = client.chat.completions.with_raw_response.create(
                     messages=[
                         {
@@ -160,8 +124,8 @@ class OpenAIService(InferenceServiceABC):
                 encoded_image=None,
             ) -> dict[str, Any]:
                 """Calls the OpenAI API and returns the API response."""
+                content = [{"type": "text", "text": user_prompt}]
                 if encoded_image:
-                    content = [{"type": "text", "text": user_prompt}]
                     content.append(
                         {
                             "type": "image_url",
@@ -170,28 +134,21 @@ class OpenAIService(InferenceServiceABC):
                             },
                         }
                     )
-                else:
-                    content = user_prompt
-                # self.client = AsyncOpenAI(
-                #     api_key = os.getenv(cls._env_key_name_),
-                #     base_url = cls._base_url_
-                #     )
-                client = self.async_client()
-                params = {
-                    "model": self.model,
-                    "messages": [
+                self.client = AsyncOpenAI()
+                response = await self.client.chat.completions.create(
+                    model=self.model,
+                    messages=[
                         {"role": "system", "content": system_prompt},
                         {"role": "user", "content": content},
                     ],
-                    "temperature": self.temperature,
-                    "max_tokens": self.max_tokens,
-                    "top_p": self.top_p,
-                    "frequency_penalty": self.frequency_penalty,
-                    "presence_penalty": self.presence_penalty,
-                    "logprobs": self.logprobs,
-                    "top_logprobs": self.top_logprobs if self.logprobs else None,
-                }
-                response = await client.chat.completions.create(**params)
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    top_p=self.top_p,
+                    frequency_penalty=self.frequency_penalty,
+                    presence_penalty=self.presence_penalty,
+                    logprobs=self.logprobs,
+                    top_logprobs=self.top_logprobs if self.logprobs else None,
+                )
                 return response.model_dump()
 
             @staticmethod

edsl/inference_services/registry.py

@@ -6,8 +6,7 @@ from edsl.inference_services.OpenAIService import OpenAIService
 from edsl.inference_services.AnthropicService import AnthropicService
 from edsl.inference_services.DeepInfraService import DeepInfraService
 from edsl.inference_services.GoogleService import GoogleService
-from edsl.inference_services.GroqService import GroqService
 
 default = InferenceServicesCollection(
-    [OpenAIService, AnthropicService, DeepInfraService, GoogleService, GroqService]
+    [OpenAIService, AnthropicService, DeepInfraService, GoogleService]
 )

edsl/jobs/Jobs.py

@@ -319,11 +319,7 @@ class Jobs(Base):
         self.scenarios = self.scenarios or [Scenario()]
         for agent, scenario, model in product(self.agents, self.scenarios, self.models):
             yield Interview(
-                survey=self.survey,
-                agent=agent,
-                scenario=scenario,
-                model=model,
-                skip_retry=self.skip_retry,
+                survey=self.survey, agent=agent, scenario=scenario, model=model
             )
 
     def create_bucket_collection(self) -> BucketCollection:
@@ -413,12 +409,6 @@ class Jobs(Base):
                 if warn:
                     warnings.warn(message)
 
-    @property
-    def skip_retry(self):
-        if not hasattr(self, "_skip_retry"):
-            return False
-        return self._skip_retry
-
     def run(
         self,
         n: int = 1,
@@ -433,7 +423,6 @@ class Jobs(Base):
         print_exceptions=True,
         remote_cache_description: Optional[str] = None,
         remote_inference_description: Optional[str] = None,
-        skip_retry: bool = False,
     ) -> Results:
         """
         Runs the Job: conducts Interviews and returns their results.
@@ -452,7 +441,6 @@ class Jobs(Base):
         from edsl.coop.coop import Coop
 
         self._check_parameters()
-        self._skip_retry = skip_retry
 
         if batch_mode is not None:
             raise NotImplementedError(
@@ -487,7 +475,6 @@ class Jobs(Base):
                 self,
                 description=remote_inference_description,
                 status="queued",
-                iterations=n,
             )
             time_queued = datetime.now().strftime("%m/%d/%Y %I:%M:%S %p")
             job_uuid = remote_job_creation_data.get("uuid")
@@ -642,9 +629,9 @@ class Jobs(Base):
         results = JobsRunnerAsyncio(self).run(*args, **kwargs)
         return results
 
-    async def run_async(self, cache=None, n=1, **kwargs):
+    async def run_async(self, cache=None, **kwargs):
         """Run the job asynchronously."""
-        results = await JobsRunnerAsyncio(self).run_async(cache=cache, n=n, **kwargs)
+        results = await JobsRunnerAsyncio(self).run_async(cache=cache, **kwargs)
         return results
 
     def all_question_parameters(self):
@@ -724,10 +711,7 @@ class Jobs(Base):
     #######################
     @classmethod
     def example(
-        cls,
-        throw_exception_probability: int = 0,
-        randomize: bool = False,
-        test_model=False,
+        cls, throw_exception_probability: int = 0, randomize: bool = False
     ) -> Jobs:
         """Return an example Jobs instance.
 
@@ -745,11 +729,6 @@ class Jobs(Base):
 
         addition = "" if not randomize else str(uuid4())
 
-        if test_model:
-            from edsl.language_models import LanguageModel
-
-            m = LanguageModel.example(test_model=True)
-
         # (status, question, period)
         agent_answers = {
             ("Joyful", "how_feeling", "morning"): "OK",
@@ -797,10 +776,7 @@ class Jobs(Base):
                 Scenario({"period": "afternoon"}),
             ]
         )
-        if test_model:
-            job = base_survey.by(m).by(scenario_list).by(joy_agent, sad_agent)
-        else:
-            job = base_survey.by(scenario_list).by(joy_agent, sad_agent)
+        job = base_survey.by(scenario_list).by(joy_agent, sad_agent)
 
         return job
 

edsl/jobs/buckets/TokenBucket.py

@@ -100,9 +100,7 @@ class TokenBucket:
         available_tokens = min(self.capacity, self.tokens + refill_amount)
         return max(0, requested_tokens - available_tokens) / self.refill_rate
 
-    async def get_tokens(
-        self, amount: Union[int, float] = 1, cheat_bucket_capacity=True
-    ) -> None:
+    async def get_tokens(self, amount: Union[int, float] = 1) -> None:
         """Wait for the specified number of tokens to become available.
 
 
@@ -118,20 +116,14 @@ class TokenBucket:
         True
 
         >>> bucket = TokenBucket(bucket_name="test", bucket_type="test", capacity=10, refill_rate=1)
-        >>> asyncio.run(bucket.get_tokens(11, cheat_bucket_capacity=False))
+        >>> asyncio.run(bucket.get_tokens(11))
         Traceback (most recent call last):
         ...
         ValueError: Requested amount exceeds bucket capacity. Bucket capacity: 10, requested amount: 11. As the bucket never overflows, the requested amount will never be available.
-        >>> asyncio.run(bucket.get_tokens(11, cheat_bucket_capacity=True))
         """
         if amount > self.capacity:
-            if not cheat_bucket_capacity:
-                msg = f"Requested amount exceeds bucket capacity. Bucket capacity: {self.capacity}, requested amount: {amount}. As the bucket never overflows, the requested amount will never be available."
-                raise ValueError(msg)
-            else:
-                self.tokens = 0  # clear the bucket but let it go through
-                return
-
+            msg = f"Requested amount exceeds bucket capacity. Bucket capacity: {self.capacity}, requested amount: {amount}. As the bucket never overflows, the requested amount will never be available."
+            raise ValueError(msg)
         while self.tokens < amount:
             self.refill()
             await asyncio.sleep(0.01)  # Sleep briefly to prevent busy waiting

edsl/jobs/interviews/Interview.py

@@ -14,8 +14,8 @@ from edsl.jobs.tasks.TaskCreators import TaskCreators
 from edsl.jobs.interviews.InterviewStatusLog import InterviewStatusLog
 from edsl.jobs.interviews.interview_exception_tracking import (
     InterviewExceptionCollection,
+    InterviewExceptionEntry,
 )
-from edsl.jobs.interviews.InterviewExceptionEntry import InterviewExceptionEntry
 from edsl.jobs.interviews.retry_management import retry_strategy
 from edsl.jobs.interviews.InterviewTaskBuildingMixin import InterviewTaskBuildingMixin
 from edsl.jobs.interviews.InterviewStatusMixin import InterviewStatusMixin
@@ -44,7 +44,6 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         iteration: int = 0,
         cache: Optional["Cache"] = None,
         sidecar_model: Optional["LanguageModel"] = None,
-        skip_retry=False,
     ):
         """Initialize the Interview instance.
 
@@ -88,7 +87,6 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         self.task_creators = TaskCreators()  # tracks the task creators
         self.exceptions = InterviewExceptionCollection()
         self._task_status_log_dict = InterviewStatusLog()
-        self.skip_retry = skip_retry
 
         # dictionary mapping question names to their index in the survey.
         self.to_index = {
@@ -96,30 +94,6 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
             for index, question_name in enumerate(self.survey.question_names)
         }
 
-    def _to_dict(self, include_exceptions=False) -> dict[str, Any]:
-        """Return a dictionary representation of the Interview instance.
-        This is just for hashing purposes.
-
-        >>> i = Interview.example()
-        >>> hash(i)
-        1646262796627658719
-        """
-        d = {
-            "agent": self.agent._to_dict(),
-            "survey": self.survey._to_dict(),
-            "scenario": self.scenario._to_dict(),
-            "model": self.model._to_dict(),
-            "iteration": self.iteration,
-            "exceptions": {},
-        }
-        if include_exceptions:
-            d["exceptions"] = self.exceptions.to_dict()
-
-    def __hash__(self) -> int:
-        from edsl.utilities.utilities import dict_hash
-
-        return dict_hash(self._to_dict())
-
     async def async_conduct_interview(
         self,
         *,
@@ -160,7 +134,8 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         <BLANKLINE>
 
         >>> i.exceptions
-        {'q0': ...
+        {'q0': [{'exception': "Exception('This is a test error')", 'time': ..., 'traceback': ...
+
         >>> i = Interview.example()
         >>> result, _ = asyncio.run(i.async_conduct_interview(stop_on_exception = True))
         Traceback (most recent call last):
@@ -229,9 +204,13 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
         {}
         >>> i._record_exception(i.tasks[0], Exception("An exception occurred."))
         >>> i.exceptions
-        {'q0': ...
+        {'q0': [{'exception': "Exception('An exception occurred.')", 'time': ..., 'traceback': 'NoneType: None\\n'}]}
         """
-        exception_entry = InterviewExceptionEntry(exception)
+        exception_entry = InterviewExceptionEntry(
+            exception=repr(exception),
+            time=time.time(),
+            traceback=traceback.format_exc(),
+        )
         self.exceptions.add(task.get_name(), exception_entry)
 
     @property
@@ -272,7 +251,6 @@ class Interview(InterviewStatusMixin, InterviewTaskBuildingMixin):
             model=self.model,
             iteration=iteration,
             cache=cache,
-            skip_retry=self.skip_retry,
         )
 
     @classmethod