From 6086953b3667c25cb78e7226d9590128640c3056 Mon Sep 17 00:00:00 2001
From: Badiboy <badialex@gmail.com>
Date: Fri, 18 Sep 2026 23:34:17 +0300
Subject: [PATCH 1/2] Async retry fix:
 https://github.com/eternnoir/pyTelegramBotAPI/pull/2599 Proposed retry
 extension to handle file uploading retry correctly.

---
 telebot/apihelper.py      | 51 +++++++++++++++++++++++
 telebot/asyncio_helper.py | 86 +++++++++++++++++++++++++++++++--------
 2 files changed, 121 insertions(+), 16 deletions(-)

diff --git a/telebot/apihelper.py b/telebot/apihelper.py
index a687066f1..f46b9e99e 100644
--- a/telebot/apihelper.py
+++ b/telebot/apihelper.py
@@ -81,6 +81,50 @@ def _get_req_session(reset=False):
         return util.per_thread('req_session', lambda: session if session else requests.sessions.Session(), reset)
 
 
+def _get_retryable_file_positions(files):
+    """Return upload stream positions, or None when an upload cannot be rewound."""
+    positions = []
+    if not files:
+        return positions
+
+    for value in files.values():
+        if isinstance(value, (tuple, list)):
+            if len(value) < 2:
+                continue
+            value = value[1]
+        if not hasattr(value, 'read'):
+            continue
+
+        try:
+            positions.append((value, value.tell()))
+        except (AttributeError, OSError, ValueError):
+            return None
+
+    return positions
+
+
+def _rewind_file_positions(positions):
+    """
+    Restore upload streams to the positions captured before the first request.
+
+    ``requests`` builds a new multipart body for every call, but it reads each
+    file object while constructing that body. If a request fails after a file
+    has been read, its stream can be positioned at EOF. Retrying without a
+    rewind would then produce an empty or truncated upload.
+
+    ``positions`` is collected before the first request by
+    :func:`_get_retryable_file_positions`. A ``False`` result means that at
+    least one stream cannot safely be rewound. The caller must then stop
+    retrying rather than risk sending a corrupted multipart body.
+    """
+    try:
+        for file, position in positions:
+            file.seek(position)
+    except (AttributeError, OSError, ValueError):
+        return False
+    return True
+
+
 def _make_request(token, method_name, method='get', params=None, files=None):
     """
     Makes a request to the Telegram API.
@@ -137,6 +181,7 @@ def _make_request(token, method_name, method='get', params=None, files=None):
     elif RETRY_ON_ERROR and RETRY_ENGINE == 1:
         got_result = False
         current_try = 0
+        file_positions = _get_retryable_file_positions(files)
         while not got_result and current_try<MAX_RETRIES-1:
             current_try+=1
             try:
@@ -146,12 +191,18 @@ def _make_request(token, method_name, method='get', params=None, files=None):
                 got_result = True
             except HTTPError:
                 logger.debug("HTTP Error on {0} method (Try #{1})".format(method_name, current_try))
+                if file_positions is None or not _rewind_file_positions(file_positions):
+                    raise
                 time.sleep(RETRY_TIMEOUT)
             except ConnectionError:
                 logger.debug("Connection Error on {0} method (Try #{1})".format(method_name, current_try))
+                if file_positions is None or not _rewind_file_positions(file_positions):
+                    raise
                 time.sleep(RETRY_TIMEOUT)
             except Timeout:
                 logger.debug("Timeout Error on {0} method (Try #{1})".format(method_name, current_try))
+                if file_positions is None or not _rewind_file_positions(file_positions):
+                    raise
                 time.sleep(RETRY_TIMEOUT)
         if not got_result:
             result = _get_req_session().request(
diff --git a/telebot/asyncio_helper.py b/telebot/asyncio_helper.py
index c54b8ec13..5a1b614b2 100644
--- a/telebot/asyncio_helper.py
+++ b/telebot/asyncio_helper.py
@@ -26,6 +26,8 @@
 
 REQUEST_TIMEOUT = 300
 MAX_RETRIES = 3
+RETRY_ON_ERROR = False
+RETRY_TIMEOUT = 2
 
 REQUEST_LIMIT = 50
 
@@ -66,6 +68,54 @@ async def get_session(self):
 
 session_manager = SessionManager()
 
+
+def _get_retryable_file_positions(files):
+    """Return upload stream positions, or None when an upload cannot be rewound."""
+    positions = []
+    if not files:
+        return positions
+
+    for value in files.values():
+        if isinstance(value, tuple):
+            if len(value) != 2:
+                continue
+            value = value[1]
+        if isinstance(value, types.InputFile):
+            value = value.file
+        if not hasattr(value, 'read'):
+            continue
+
+        try:
+            positions.append((value, value.tell()))
+        except (AttributeError, OSError, ValueError):
+            return None
+
+    return positions
+
+
+def _rewind_file_positions(positions):
+    """
+    Restore upload streams to the positions captured before the first request.
+
+    aiohttp consumes a ``FormData`` object while building a multipart request.
+    Retrying therefore requires a new ``FormData`` instance, but that alone is
+    insufficient: if the first request failed after its body was read, the
+    underlying file objects can be positioned at EOF. Without rewinding them,
+    a retry could send an empty or truncated upload.
+
+    ``positions`` is collected before the first request by
+    :func:`_get_retryable_file_positions`. A ``False`` result means that at
+    least one stream cannot safely be rewound. The caller must then stop
+    retrying rather than risk sending a corrupted multipart body.
+    """
+    try:
+        for file, position in positions:
+            file.seek(position)
+    except (AttributeError, OSError, ValueError):
+        return False
+    return True
+
+
 async def _process_request(token, url, method='get', params=None, files=None, **kwargs):
     # Let's resolve all timeout parameters.
     # getUpdates parameter may contain 2 parameters: request_timeout & timeout.
@@ -86,32 +136,36 @@ async def _process_request(token, url, method='get', params=None, files=None, **
     request_timeout = REQUEST_TIMEOUT if request_timeout is None else request_timeout
     
 
-    # Preparing data by adding all parameters and files to FormData
-    params = _prepare_data(params, files)
-
     timeout = aiohttp.ClientTimeout(total=request_timeout)
-    got_result = False
-    current_try=0
+    max_attempts = max(1, MAX_RETRIES if RETRY_ON_ERROR else 1)
+    file_positions = _get_retryable_file_positions(files)
+    last_error = None
     session = await session_manager.get_session()
-    while not got_result and current_try<MAX_RETRIES-1:
-        current_try +=1
+    for current_try in range(1, max_attempts + 1):
+        # FormData is consumed when aiohttp builds a multipart request, so it
+        # must be created again for each retry.
+        request_data = _prepare_data(params, files)
         try:
-            async with session.request(method=method, url=API_URL.format(token, url), data=params, timeout=timeout, proxy=proxy) as resp:
-                got_result = True
+            async with session.request(method=method, url=API_URL.format(token, url), data=request_data, timeout=timeout, proxy=proxy) as resp:
                 logger.debug("Request: method={0} url={1} params={2} files={3} request_timeout={4} current_try={5}".format(method, url, params, files, request_timeout, current_try).replace(token, token.split(':')[0] + ":{TOKEN}"))
                 
                 json_result = await _check_result(url, resp)
                 if json_result:
                     return json_result['result']
+                return None
         except (ApiTelegramException,ApiInvalidJSONException, ApiHTTPException) as e:
             raise e
-        except aiohttp.ClientError as e:
-            logger.error('Aiohttp ClientError: {0}'.format(e.__class__.__name__))
-        except Exception as e:
-            logger.error(f'Unknown error: {e.__class__.__name__}')
-        if not got_result:
-            raise RequestTimeout("Request timeout. Request: method={0} url={1} params={2} files={3} request_timeout={4}".format(method, url, params, files, request_timeout, current_try))
-    return None
+        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+            last_error = e
+            logger.error('Aiohttp request error: {0} (try #{1})'.format(e.__class__.__name__, current_try))
+
+            if current_try == max_attempts:
+                break
+            if file_positions is None or not _rewind_file_positions(file_positions):
+                break
+            await asyncio.sleep(RETRY_TIMEOUT)
+
+    raise RequestTimeout("Request timeout. Request: method={0} url={1} params={2} files={3} request_timeout={4} current_try={5}".format(method, url, params, files, request_timeout, current_try)) from last_error
         
 def _prepare_file(obj):
     """

From 78d23a01fa7d386363dea1f9c92664b5b7e2e3e7 Mon Sep 17 00:00:00 2001
From: Badiboy <badialex@gmail.com>
Date: Fri, 18 Sep 2026 23:43:23 +0300
Subject: [PATCH 2/2] Functions unification.

---
 telebot/apihelper.py      | 56 ++++++------------------------------
 telebot/asyncio_helper.py | 60 +++++++--------------------------------
 telebot/util.py           | 35 +++++++++++++++++++++++
 3 files changed, 54 insertions(+), 97 deletions(-)

diff --git a/telebot/apihelper.py b/telebot/apihelper.py
index f46b9e99e..cd7d0f97e 100644
--- a/telebot/apihelper.py
+++ b/telebot/apihelper.py
@@ -81,50 +81,6 @@ def _get_req_session(reset=False):
         return util.per_thread('req_session', lambda: session if session else requests.sessions.Session(), reset)
 
 
-def _get_retryable_file_positions(files):
-    """Return upload stream positions, or None when an upload cannot be rewound."""
-    positions = []
-    if not files:
-        return positions
-
-    for value in files.values():
-        if isinstance(value, (tuple, list)):
-            if len(value) < 2:
-                continue
-            value = value[1]
-        if not hasattr(value, 'read'):
-            continue
-
-        try:
-            positions.append((value, value.tell()))
-        except (AttributeError, OSError, ValueError):
-            return None
-
-    return positions
-
-
-def _rewind_file_positions(positions):
-    """
-    Restore upload streams to the positions captured before the first request.
-
-    ``requests`` builds a new multipart body for every call, but it reads each
-    file object while constructing that body. If a request fails after a file
-    has been read, its stream can be positioned at EOF. Retrying without a
-    rewind would then produce an empty or truncated upload.
-
-    ``positions`` is collected before the first request by
-    :func:`_get_retryable_file_positions`. A ``False`` result means that at
-    least one stream cannot safely be rewound. The caller must then stop
-    retrying rather than risk sending a corrupted multipart body.
-    """
-    try:
-        for file, position in positions:
-            file.seek(position)
-    except (AttributeError, OSError, ValueError):
-        return False
-    return True
-
-
 def _make_request(token, method_name, method='get', params=None, files=None):
     """
     Makes a request to the Telegram API.
@@ -181,7 +137,11 @@ def _make_request(token, method_name, method='get', params=None, files=None):
     elif RETRY_ON_ERROR and RETRY_ENGINE == 1:
         got_result = False
         current_try = 0
-        file_positions = _get_retryable_file_positions(files)
+        file_streams = (
+            value[1] if isinstance(value, (tuple, list)) and len(value) >= 2 else value
+            for value in (files or {}).values()
+        )
+        file_positions = util._get_retryable_file_positions(file_streams)
         while not got_result and current_try<MAX_RETRIES-1:
             current_try+=1
             try:
@@ -191,17 +151,17 @@ def _make_request(token, method_name, method='get', params=None, files=None):
                 got_result = True
             except HTTPError:
                 logger.debug("HTTP Error on {0} method (Try #{1})".format(method_name, current_try))
-                if file_positions is None or not _rewind_file_positions(file_positions):
+                if file_positions is None or not util._rewind_file_positions(file_positions):
                     raise
                 time.sleep(RETRY_TIMEOUT)
             except ConnectionError:
                 logger.debug("Connection Error on {0} method (Try #{1})".format(method_name, current_try))
-                if file_positions is None or not _rewind_file_positions(file_positions):
+                if file_positions is None or not util._rewind_file_positions(file_positions):
                     raise
                 time.sleep(RETRY_TIMEOUT)
             except Timeout:
                 logger.debug("Timeout Error on {0} method (Try #{1})".format(method_name, current_try))
-                if file_positions is None or not _rewind_file_positions(file_positions):
+                if file_positions is None or not util._rewind_file_positions(file_positions):
                     raise
                 time.sleep(RETRY_TIMEOUT)
         if not got_result:
diff --git a/telebot/asyncio_helper.py b/telebot/asyncio_helper.py
index 5a1b614b2..a48a3971c 100644
--- a/telebot/asyncio_helper.py
+++ b/telebot/asyncio_helper.py
@@ -69,53 +69,6 @@ async def get_session(self):
 session_manager = SessionManager()
 
 
-def _get_retryable_file_positions(files):
-    """Return upload stream positions, or None when an upload cannot be rewound."""
-    positions = []
-    if not files:
-        return positions
-
-    for value in files.values():
-        if isinstance(value, tuple):
-            if len(value) != 2:
-                continue
-            value = value[1]
-        if isinstance(value, types.InputFile):
-            value = value.file
-        if not hasattr(value, 'read'):
-            continue
-
-        try:
-            positions.append((value, value.tell()))
-        except (AttributeError, OSError, ValueError):
-            return None
-
-    return positions
-
-
-def _rewind_file_positions(positions):
-    """
-    Restore upload streams to the positions captured before the first request.
-
-    aiohttp consumes a ``FormData`` object while building a multipart request.
-    Retrying therefore requires a new ``FormData`` instance, but that alone is
-    insufficient: if the first request failed after its body was read, the
-    underlying file objects can be positioned at EOF. Without rewinding them,
-    a retry could send an empty or truncated upload.
-
-    ``positions`` is collected before the first request by
-    :func:`_get_retryable_file_positions`. A ``False`` result means that at
-    least one stream cannot safely be rewound. The caller must then stop
-    retrying rather than risk sending a corrupted multipart body.
-    """
-    try:
-        for file, position in positions:
-            file.seek(position)
-    except (AttributeError, OSError, ValueError):
-        return False
-    return True
-
-
 async def _process_request(token, url, method='get', params=None, files=None, **kwargs):
     # Let's resolve all timeout parameters.
     # getUpdates parameter may contain 2 parameters: request_timeout & timeout.
@@ -138,7 +91,16 @@ async def _process_request(token, url, method='get', params=None, files=None, **
 
     timeout = aiohttp.ClientTimeout(total=request_timeout)
     max_attempts = max(1, MAX_RETRIES if RETRY_ON_ERROR else 1)
-    file_positions = _get_retryable_file_positions(files)
+    file_streams = []
+    for value in (files or {}).values():
+        if isinstance(value, tuple):
+            if len(value) != 2:
+                continue
+            value = value[1]
+        if isinstance(value, types.InputFile):
+            value = value.file
+        file_streams.append(value)
+    file_positions = util._get_retryable_file_positions(file_streams)
     last_error = None
     session = await session_manager.get_session()
     for current_try in range(1, max_attempts + 1):
@@ -161,7 +123,7 @@ async def _process_request(token, url, method='get', params=None, files=None, **
 
             if current_try == max_attempts:
                 break
-            if file_positions is None or not _rewind_file_positions(file_positions):
+            if file_positions is None or not util._rewind_file_positions(file_positions):
                 break
             await asyncio.sleep(RETRY_TIMEOUT)
 
diff --git a/telebot/util.py b/telebot/util.py
index bbb9b98af..7eb62e180 100644
--- a/telebot/util.py
+++ b/telebot/util.py
@@ -536,6 +536,41 @@ def per_thread(key, construct_value, reset=False):
     return getattr(thread_local, key)
 
 
+def _get_retryable_file_positions(file_streams):
+    """Return stream positions, or ``None`` when one cannot be rewound.
+
+    Multipart encoders consume file streams while preparing a request. A retry
+    must restore every stream to its position before the first attempt;
+    otherwise, it can upload an empty or truncated file. The caller supplies
+    already-extracted file-like objects so this helper remains independent of
+    any HTTP client's multipart value format.
+    """
+    positions = []
+    for file_stream in file_streams:
+        if not hasattr(file_stream, 'read'):
+            continue
+        try:
+            positions.append((file_stream, file_stream.tell()))
+        except (AttributeError, OSError, ValueError):
+            return None
+    return positions
+
+
+def _rewind_file_positions(positions):
+    """Restore streams to positions returned by :func:`_get_retryable_file_positions`.
+
+    A ``False`` result means that at least one stream cannot safely be
+    restored. In that case, the caller must not retry the multipart request,
+    because doing so could send an empty or truncated upload.
+    """
+    try:
+        for file_stream, position in positions:
+            file_stream.seek(position)
+    except (AttributeError, OSError, ValueError):
+        return False
+    return True
+
+
 def deprecated(warn: bool = True, alternative: Optional[Callable] = None, deprecation_text=None):
     """
     Use this decorator to mark functions as deprecated.