Update generate strings

regexsolver/clients/asynchronous.py

@@ -98,25 +98,24 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
 
     # --- HELPER ---
     async def _execute_with_retry(self, api_method, **kwargs):
-        max_retries = 5
-        retries = 0
+        retried = False
         while True:
             await self._rate_limiter.wait()
             try:
                 return await api_method(**kwargs)
             except ApiException as e:
                 if e.status == 429:
-                    retries += 1
-                    if retries > max_retries:
+                    if retried:
                         logger.error("Max retries exceeded for 429 Too Many Requests.")
                         raise TooManyRequestsError(
                             "Max retries exceeded for 429 Too Many Requests.",
                             status_code=429,
                         )
+                    retried = True
                     headers = e.headers or {}
                     retry_after = float(headers.get("Retry-After", 1))
                     logger.debug(
-                        f"429 Too Many Requests hit (Attempt {retries}/{max_retries}). "
+                        "429 Too Many Requests hit. "
                         f"Triggering rate limiter for {retry_after} seconds."
                     )
                     await self._rate_limiter.trigger(retry_after)
@@ -580,13 +579,18 @@ async def repeat(
 
     # --- GENERATE ---
     async def generate_strings(
-        self, term: Term, count: int, execution_timeout: Optional[int] = None
+        self,
+        term: Term,
+        count: int,
+        offset: int,
+        execution_timeout: Optional[int] = None,
     ) -> List[str]:
-        """Generates up to `count` unique strings matched by the term.
+        """Generates up to `count` distinct strings matched by 'term', skipping the first 'offset' strings.
 
         Args:
             term: The term to sample generated strings from.
             count: The maximum number of unique strings to return.
+            offset: Number of matched strings to skip before starting to collect the results. Used for pagination.
             execution_timeout: Timeout in milliseconds for the operation.
 
         Returns:
@@ -595,6 +599,7 @@ async def generate_strings(
         request = GenerateStringsRequest(
             term=term._api_model,
             count=count,
+            offset=offset,
             options=self._build_options(execution_timeout),
         )
         response = await self._execute_with_retry(

regexsolver/clients/synchronous.py

@@ -338,18 +338,23 @@ def repeat(
 
     # --- GENERATE ---
     def generate_strings(
-        self, term: Term, count: int, execution_timeout: Optional[int] = None
+        self,
+        term: Term,
+        count: int,
+        offset: int,
+        execution_timeout: Optional[int] = None,
     ) -> List[str]:
-        """Generates up to `count` unique strings matched by the term.
+        """Generates up to `count` distinct strings matched by 'term', skipping the first 'offset' strings.
 
         Args:
             term: The term to sample generated strings from.
             count: The maximum number of unique strings to return.
+            offset: Number of matched strings to skip before starting to collect the results. Used for pagination.
             execution_timeout: Timeout in milliseconds for the operation.
 
         Returns:
             List[str]: A list of strings that match the term.
         """
         return self._run_sync(
-            self._aio.generate_strings(term, count, execution_timeout)
+            self._aio.generate_strings(term, count, offset, execution_timeout)
         )

regexsolver/generated/models/generate_strings_request.py

@@ -26,12 +26,13 @@
 
 class GenerateStringsRequest(BaseModel):
     """
-    Request to generate up to 'count' distinct strings matched by 'term'.
+    Request to generate up to 'count' distinct strings matched by 'term', skipping the first 'offset' strings.
     """ # noqa: E501
-    term: Term = Field(description="Source term to sample from.")
+    term: Term = Field(description="Source term to generate strings from.")
     count: StrictInt = Field(description="Maximum number of unique strings to return.")
+    offset: StrictInt = Field(description="Number of matched strings to skip before starting to collect the results. Used for pagination.")
     options: Optional[RequestOptions] = None
-    __properties: ClassVar[List[str]] = ["term", "count", "options"]
+    __properties: ClassVar[List[str]] = ["term", "count", "offset", "options"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -92,6 +93,7 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         _obj = cls.model_validate({
             "term": Term.from_dict(obj["term"]) if obj.get("term") is not None else None,
             "count": obj.get("count"),
+            "offset": obj.get("offset"),
             "options": RequestOptions.from_dict(obj["options"]) if obj.get("options") is not None else None
         })
         return _obj