ofscraper 3.13.dev4__tar.gz → 3.13.dev6__tar.gz

{ofscraper-3.13.dev4 → ofscraper-3.13.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ofscraper
-Version: 3.13.dev4
+Version: 3.13.dev6
 Summary: automatically scrape onlyfans
 Author: datawhores
 Author-email: datawhores@riseup.net
@@ -11,7 +11,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: pyinstaller
 Requires-Dist: aiofiles (>=23.2.1,<24.0.0)
-Requires-Dist: aiohttp (==3.10.11)
 Requires-Dist: aiolimiter (>=1.1.0,<2.0.0)
 Requires-Dist: aioprocessing (>=2.0.1,<3.0.0)
 Requires-Dist: aiosqlite (>=0.20.0,<0.21.0)
@@ -26,7 +25,9 @@ Requires-Dist: diskcache (>=5.6.3,<6.0.0)
 Requires-Dist: dunamai (>=1.19.2,<2.0.0)
 Requires-Dist: faust-cchardet (>=2.1.19,<3.0.0)
 Requires-Dist: filelock (>=3.13.1,<4.0.0)
-Requires-Dist: httpx[http2] (>=0.27.0,<0.28.0)
+Requires-Dist: httpx-aiohttp (>=0.1.2,<0.2.0)
+Requires-Dist: httpx-curl-cffi (>=0.1.3,<0.2.0)
+Requires-Dist: httpx[http2] (>=0.28.1,<0.29.0)
 Requires-Dist: humanfriendly (>=10.0,<11.0)
 Requires-Dist: idna (==3.7)
 Requires-Dist: inquirerpy (>=0.3.4,<0.4.0)
@@ -51,7 +52,6 @@ Requires-Dist: speedtest-cli (>=2.1.3,<3.0.0)
 Requires-Dist: tenacity (>=8.2.3,<9.0.0)
 Requires-Dist: textual (==1.0.0)
 Requires-Dist: tqdm (>=4.66.4,<5.0.0)
-Requires-Dist: ua-generator (>=2.0.5,<3.0.0)
 Requires-Dist: uvloop (>=0.19.0,<0.20.0) ; sys_platform == "linux" or sys_platform == "linux2"
 Requires-Dist: win32-setctime (>=1.1.0,<2.0.0)
 Requires-Dist: xxhash (>=3.4.1,<4.0.0)

{ofscraper-3.13.dev4 → ofscraper-3.13.dev6}/ofscraper/classes/sessionmanager/download.py

@@ -14,24 +14,30 @@ from ofscraper.classes.sessionmanager.sessionmanager import (
 )
 from ofscraper.commands.scraper.actions.download.utils.leaky import LeakyBucket
 import ofscraper.utils.settings as settings
+from ofscraper.commands.scraper.actions.download.utils.chunk import get_chunk_timeout
 
 
 class download_session(sessionManager.sessionManager):
     def __init__(
         self, sem_count=None, retries=None, wait_min=None, wait_max=None, log=None
     ) -> None:
-        sem_count = sem_count or common_globals.sem
         retries = retries or get_download_req_retries()
         wait_min = wait_min or constants.getattr("OF_MIN_WAIT_API")
         wait_max = wait_max or constants.getattr("OF_MAX_WAIT_API")
+        read_timeout=get_chunk_timeout()
         log = log or common_globals.log
         self.leaky_bucket = LeakyBucket(settings.get_settings().download_limit, 1)
+
+
+
+
         super().__init__(
             sem_count=sem_count,
             retries=retries,
             wait_min=wait_min,
             wait_max=wait_max,
             log=log,
+            read_timeout=read_timeout
         )
 
     @contextlib.asynccontextmanager
@@ -56,19 +62,6 @@ class download_session(sessionManager.sessionManager):
         t.request = t.request
         return t
 
-    async def _aio_funct(self, method, *args, **kwargs):
-        # public function forces context manager use
-        r = await self._session._request(method, *args, **kwargs)
-        r.text_ = r.text
-        r.json_ = r.json
-        r.iter_chunked = self.chunk_with_limit(r.content.iter_chunked)
-        r.iter_chunks = self.chunk_with_limit(r.content.iter_chunks)
-        r.request = r.request_info
-        r.status_code = r.status
-        r.read_ = r.content.read
-        r.eof = r.content.at_eof
-        return r
-
     async def factoryasync(self, input):
         if callable(input):
             return input()
@@ -87,14 +80,10 @@ class download_session(sessionManager.sessionManager):
 
 
 class cdm_session(sessionManager.sessionManager):
-    def __init__(self, backend=None, sem_count=None) -> None:
-        backend = backend or "httpx"
-        sem_count = sem_count or common_globals.sem
-        super().__init__(sem_count=sem_count, backend=backend)
+    def __init__(self,  sem_count=None) -> None:
+        super().__init__(sem_count=sem_count)
 
 
 class cdm_session_manual(ofsessionmanager.OFSessionManager):
-    def __init__(self, backend=None, sem_count=None) -> None:
-        backend = backend or "httpx"
-        sem_count = sem_count or common_globals.sem
-        super().__init__(sem_count=sem_count, backend=backend)
+    def __init__(self,  sem_count=None) -> None:
+        super().__init__(sem_count=sem_count)

{ofscraper-3.13.dev4 → ofscraper-3.13.dev6}/ofscraper/classes/sessionmanager/ofsession.py

@@ -15,7 +15,7 @@ from ofscraper.classes.sessionmanager.sessionmanager import (
 class OFSessionManager(sessionManager):
     def __init__(
         self,
-        backend=None,
+        
         connect_timeout=None,
         total_timeout=None,
         read_timeout=None,
@@ -50,7 +50,6 @@ class OFSessionManager(sessionManager):
             wait_max if wait_max is not None else constants.getattr("OF_MAX_WAIT_API")
         )
         super().__init__(
-            backend,
             connect_timeout,
             total_timeout,
             read_timeout,

{ofscraper-3.13.dev4 → ofscraper-3.13.dev6}/ofscraper/classes/sessionmanager/sessionmanager.py

@@ -1,24 +1,23 @@
 import asyncio
 import contextlib
 import logging
-import ssl
 import threading
 import time
 import traceback
 
-import aiohttp
 import arrow
-import certifi
 import httpx
 import tenacity
 from tenacity import AsyncRetrying, Retrying, retry_if_not_exception_type
 
 import ofscraper.utils.auth.request as auth_requests
-import ofscraper.utils.config.data as data
 import ofscraper.utils.constants as constants
 from ofscraper.utils.auth.utils.warning.print import print_auth_warning
-import ofscraper.utils.settings as settings
-import ua_generator
+# from httpx_curl_cffi import  AsyncCurlTransport, CurlOpt
+from httpx_aiohttp import AiohttpTransport
+from aiohttp import ClientSession
+import aiohttp
+
 
 
 TOO_MANY = "too_many"
@@ -27,7 +26,6 @@ FORCED_NEW = "get_new_sign"
 SIGN = "get_sign"
 COOKIES = "get_cookies_str"
 HEADERS = "create_header"
-AGENT=str(ua_generator.generate())
 
 
 def is_rate_limited(exception, sleeper):
@@ -52,6 +50,7 @@ def check_400(exception):
         time.sleep(8)
 
 
+
 def is_provided_exception_number(exception, *numbers):
     return (
         isinstance(exception, aiohttp.ClientResponseError)
@@ -70,7 +69,6 @@ def is_provided_exception_number(exception, *numbers):
         )
     )
 
-
 class SessionSleep:
     def __init__(self, sleep=None, difmin=None):
         self._sleep = None
@@ -164,7 +162,6 @@ class CustomTenacity(AsyncRetrying):
 class sessionManager:
     def __init__(
         self,
-        backend=None,
         connect_timeout=None,
         total_timeout=None,
         read_timeout=None,
@@ -188,17 +185,15 @@ class sessionManager:
     ):
         connect_timeout = connect_timeout or constants.getattr("CONNECT_TIMEOUT")
         total_timeout = total_timeout or constants.getattr("TOTAL_TIMEOUT")
-        read_timeout = read_timeout or constants.getattr("CHUNK_READ_TIMEOUT")
         pool_timeout = pool_timeout or constants.getattr("POOL_CONNECT_TIMEOUT")
         limit = limit or constants.getattr("MAX_CONNECTIONS")
         keep_alive = keep_alive or constants.getattr("KEEP_ALIVE")
         keep_alive_exp = keep_alive_exp or constants.getattr("KEEP_ALIVE_EXP")
         proxy = proxy or constants.getattr("PROXY")
         proxy_auth = proxy_auth or constants.getattr("PROXY_AUTH")
-        self._backend = backend or data.get_backend()
         self._connect_timeout = connect_timeout
         self._total_timeout = total_timeout
-        self._read_timeout = read_timeout
+        self._read_timeout=read_timeout
         self._pool_connect_timeout = pool_timeout
         self._connect_limit = limit
         self._keep_alive = keep_alive
@@ -226,36 +221,31 @@ class sessionManager:
         if self._session:
             return
         if async_:
-            self._async = True
-            if self._backend == "aio":
-                self._session = aiohttp.ClientSession(
-                    connector=aiohttp.TCPConnector(limit=self._connect_limit),
-                )
-
-            elif self._backend == "httpx":
-                self._session = httpx.AsyncClient(
-                    http2=True,
-                    proxies=self._proxy,
-                    limits=httpx.Limits(
-                        max_keepalive_connections=self._keep_alive,
-                        max_connections=self._connect_limit,
-                        keepalive_expiry=self._keep_alive_exp,
-                    ),
-                )
+            self._session = httpx.AsyncClient(
+                http2=True,
+                proxy=self._proxy,
+                limits=httpx.Limits(
+                    max_keepalive_connections=self._keep_alive,
+                    max_connections=self._connect_limit,
+                    keepalive_expiry=self._keep_alive_exp,
+                ),
+             transport=AiohttpTransport(
+        client=lambda: ClientSession(    proxy=self._proxy,
+        connector=aiohttp.TCPConnector(limit=self._connect_limit)),
+    )
+                            
+                            )
         else:
-            self._async = False
-            if self._backend == "httpx":
-                self._session = httpx.Client(
-                    http2=True,
-                    proxies=self._proxy,
-                    limits=httpx.Limits(
-                        max_keepalive_connections=self._keep_alive,
-                        max_connections=self._connect_limit,
-                        keepalive_expiry=self._keep_alive_exp,
-                    ),
-                )
-            elif self._backend == "aio":
-                raise Exception("aiohttp is async only")
+            self._session = httpx.Client(
+                http2=True,
+                proxy=self._proxy,
+                limits=httpx.Limits(
+                    max_keepalive_connections=self._keep_alive,
+                    max_connections=self._connect_limit,
+                    keepalive_expiry=self._keep_alive_exp,
+                ),
+            )
+        self._async = async_
         return self._session
 
     # https://github.com/aio-libs/aiohttp/issues/1925
@@ -353,13 +343,7 @@ class sessionManager:
                        ):
                             headers = self._create_headers(
                                     headers, url, SIGN in actions, FORCED_NEW in actions
-                                )
-                    elif not headers or not "user-agent" in headers:
-                        headers=headers or {}
-                        headers.update({"user-agent":AGENT})
-                        
-                        
-                       
+                                )   
                     
                     cookies = self._create_cookies() if COOKIES in actions else None
                     r = self._httpx_funct(
@@ -368,7 +352,7 @@ class sessionManager:
                             total_timeout or self._total_timeout,
                             connect=connect_timeout or self._connect_timeout,
                             pool=pool_connect_timeout or self._pool_connect_timeout,
-                            read=read_timeout or self._read_timeout,
+                            read=read_timeout or self._read_timeout
                         ),
                         url=url,
                         follow_redirects=redirects,
@@ -450,9 +434,9 @@ class sessionManager:
             ),
             reraise=True,
         ):
+            await sem.acquire()
             with _:
                 r = None
-                await sem.acquire()
                 try:
                     await sleeper.async_do_sleep()
                     if (
@@ -466,51 +450,28 @@ class sessionManager:
                         )
                        
                     )
-                    elif not headers or not "user-agent" in headers:
-                        headers= headers or {}
-                        headers.update({"user-agent":AGENT})
-                        
+
 
                     cookies = self._create_cookies() if COOKIES in actions else None
                     json = json
                     params = params
-                    if self._backend == "aio":
-                        r = await self._aio_funct(
-                            method,
-                            url,
-                            timeout=aiohttp.ClientTimeout(
-                                total=total_timeout or self._total_timeout,
-                                connect=connect_timeout or self._connect_timeout,
-                                sock_connect=pool_connect_timeout
-                                or self._pool_connect_timeout,
-                                sock_read=read_timeout or self._read_timeout,
-                            ),
-                            headers=headers,
-                            cookies=cookies,
-                            allow_redirects=redirects,
-                            proxy=self._proxy,
-                            params=params,
-                            json=json,
-                            data=data,
-                            ssl=False if not settings.get_settings().ssl_validation else ssl.create_default_context(cafile=certifi.where()),
-                        )
-                    else:
-                        r = await self._httpx_funct_async(
-                            method,
-                            timeout=httpx.Timeout(
-                                total_timeout or self._total_timeout,
-                                connect=connect_timeout or self._connect_timeout,
-                                pool=pool_connect_timeout or self._pool_connect_timeout,
-                                read=read_timeout or self._read_timeout,
-                            ),
-                            follow_redirects=redirects,
-                            url=url,
-                            cookies=cookies,
-                            headers=headers,
-                            json=json,
-                            params=params,
-                            data=data,
-                        )
+                    r = await self._httpx_funct_async(
+                        method,
+                        timeout=httpx.Timeout(
+                            total_timeout or self._total_timeout,
+                            connect=connect_timeout or self._connect_timeout,
+                            pool=pool_connect_timeout or self._pool_connect_timeout,
+                            read=read_timeout or self._read_timeout
+
+                        ),
+                        follow_redirects=redirects,
+                        url=url,
+                        cookies=cookies,
+                        headers=headers,
+                        json=json,
+                        params=params,
+                        data=data,
+                    )
                     if r.status_code == 404:
                         pass
                     elif not r.ok:
@@ -532,6 +493,119 @@ class sessionManager:
         yield r
         sem.release()
 
+    @contextlib.asynccontextmanager
+    async def requests_async_stream(
+        self,
+        url=None,
+        wait_min=None,
+        wait_max=None,
+        wait_min_exponential=None,
+        wait_max_exponential=None,
+        retries=None,
+        method="get",
+        headers=None,
+        cookies=None,
+        json=None,
+        params=None,
+        redirects=True,
+        data=None,
+        log=None,
+        sem=None,
+        total_timeout=None,
+        connect_timeout=None,
+        pool_connect_timeout=None,
+        read_timeout=None,
+        sleeper=None,
+        exceptions=[],
+        actions=[],
+        *args,
+        **kwargs,
+    ):
+        wait_min = wait_min or self._wait_min
+        wait_max = wait_max or self._wait_max
+        wait_min_exponential = wait_min_exponential or self._wait_min_exponential
+        wait_max_exponential = wait_max_exponential or self._wait_max_exponential
+        log = log or self._log
+        retries = retries or self._retries
+        sem = sem or self._sem
+        sleeper = sleeper or self._sleeper
+        exceptions = exceptions or []
+        actions = actions or []
+        async for _ in CustomTenacity(
+            wait_exponential=tenacity.wait.wait_exponential(
+                multiplier=2, min=wait_min_exponential, max=wait_max_exponential
+            ),
+            retry=retry_if_not_exception_type((KeyboardInterrupt)),
+            wait_random=tenacity.wait_random(min=wait_min, max=wait_max),
+            stop=tenacity.stop.stop_after_attempt(retries),
+            before=lambda x: (
+                log.debug(f"[bold]attempt: {x.attempt_number}[bold] for {url}")
+                if x.attempt_number > 1
+                else None
+            ),
+            reraise=True,
+        ):
+            with _:
+                r = None
+                try:
+                    await sem.acquire()
+                    await sleeper.async_do_sleep()
+                    if (
+                            SIGN in actions
+                            or FORCED_NEW in actions
+                            or HEADERS in actions
+                    ): 
+                        headers = (
+                        self._create_headers(
+                            headers, url, SIGN in actions, FORCED_NEW in actions
+                        )
+                       
+                    )
+
+
+                    cookies = self._create_cookies() if COOKIES in actions else None
+                    json = json
+                    params = params
+                    r = await self._httpx_funct_async_stream(
+                        method,
+                        timeout=httpx.Timeout(
+                            total_timeout or self._total_timeout,
+                            connect=connect_timeout or self._connect_timeout,
+                            pool=pool_connect_timeout or self._pool_connect_timeout,
+                            read=read_timeout or self._read_timeout
+                        ),
+                        follow_redirects=redirects,
+                        url=url,
+                        cookies=cookies,
+                        headers=headers,
+                        json=json,
+                        params=params,
+                        data=data,
+                    )
+                    if r.status_code == 404:
+                        pass
+                    elif not r.ok:
+                        log.debug(f"[bold]failed: [bold] {r.url}")
+                        log.debug(f"[bold]status: [bold] {r.status}")
+                        log.debug(f"[bold]response text [/bold]: {await r.text_()}")
+                        log.debug(f"response headers {dict(r.headers)}")
+                        log.debug(f"requests headers mode{dict(r.request.headers)}")
+                        r.raise_for_status()
+                    yield r
+                except Exception as E:
+                    # only call from sync req like "me"
+                    # check_400(E)
+                    log.traceback_(E)
+                    log.traceback_(traceback.format_exc())
+                    if TOO_MANY in exceptions:
+                        await async_is_rate_limited(E, sleeper)
+                    raise E
+                finally:
+                    sem.release()
+                    await r.aclose()
+
+
+
     @property
     def sleep(self):
         return self._sleeper._sleep
@@ -551,6 +625,27 @@ class sessionManager:
         t.read_ = t.aread
         t.request = t.request
         return t
+    
+    async def _httpx_funct_async_stream(self, *args, **kwargs):
+        auth=kwargs.pop("auth",None)
+        follow_redirects=kwargs.pop("follow_redirects",None)
+        req=self._session.build_request(*args, **kwargs)
+        t = await self._session.send(
+            request=req,
+            follow_redirects=follow_redirects,
+            stream=True,
+            auth=auth,
+        )
+        t.ok = not t.is_error
+        t.json_ = lambda: self.factoryasync(t.json)
+        t.text_ = lambda: self.factoryasync(t.text)
+        t.status = t.status_code
+        t.iter_chunked = t.aiter_bytes
+        t.iter_chunks = t.aiter_bytes
+        t.read_ = t.aread
+        t.request = t.request
+        return t
+
 
     def _httpx_funct(self, method, **kwargs):
         t = self._session.request(method.upper(), **kwargs)
@@ -564,19 +659,6 @@ class sessionManager:
         t.read_ = t.read
         return t
 
-    async def _aio_funct(self, method, *args, **kwargs):
-        # public function forces context manager use
-        r = await self._session._request(method, *args, **kwargs)
-        r.text_ = r.text
-        r.json_ = r.json
-        r.iter_chunked = r.content.iter_chunked
-        r.iter_chunks = r.content.iter_chunks
-        r.request = r.request_info
-        r.status_code = r.status
-        r.read_ = r.content.read
-        r.eof = r.content.at_eof
-        return r
-
     async def factoryasync(self, input):
         if callable(input):
             return input()

{ofscraper-3.13.dev4 → ofscraper-3.13.dev6}/ofscraper/commands/check.py

@@ -247,7 +247,7 @@ async def post_check_retriver():
     user_dict = {}
     links = list(url_helper())
     async with manager.Manager.aget_ofsession(
-        backend="httpx",
+       
         sem_count=constants.getattr("API_REQ_CHECK_MAX"),
     ) as c:
         for ele in links:
@@ -446,7 +446,7 @@ async def message_checker_runner():
 async def message_check_retriver():
     links = list(url_helper())
     async with manager.Manager.aget_ofsession(
-        backend="httpx",
+       
     ) as c:
         for item in links:
             num_match = re.search(
@@ -523,7 +523,7 @@ async def purchase_check_retriver():
     user_dict = {}
     auth_requests.make_headers()
     async with manager.Manager.aget_ofsession(
-        backend="httpx",
+       
         sem_count=constants.getattr("API_REQ_CHECK_MAX"),
     ) as c:
         for name in settings.get_settings().check_usernames:
@@ -578,7 +578,7 @@ async def stories_checker_runner():
 async def stories_check_retriver():
     user_dict = {}
     async with manager.Manager.aget_ofsession(
-        backend="httpx",
+       
         sem_count=constants.getattr("API_REQ_CHECK_MAX"),
     ) as c:
         for user_name in settings.get_settings().check_usernames:
@@ -662,7 +662,7 @@ async def get_paid_ids(model_id, user_name):
         paid = oldpaid
     else:
         async with manager.Manager.aget_ofsession(
-            backend="httpx", sem_count=constants.getattr("API_REQ_CHECK_MAX")
+            sem_count=constants.getattr("API_REQ_CHECK_MAX")
         ) as c:
             paid = await paid_.get_paid_posts(model_id, user_name, c=c)
             set_check(paid, model_id, paid_.API)

{ofscraper-3.13.dev4 → ofscraper-3.13.dev6}/ofscraper/commands/manual.py

@@ -239,7 +239,7 @@ async def paid_failback(post_id, model_id, username):
     )
     post_id = str(post_id)
     async with manager.Manager.aget_ofsession(
-        backend="httpx",
+       
         sem_count=constants.getattr("API_REQ_CHECK_MAX"),
     ) as c:
         data = await paid.get_paid_posts(username, model_id, c=c) or []

{ofscraper-3.13.dev4 → ofscraper-3.13.dev6}/ofscraper/commands/metadata/metadata.py

@@ -48,7 +48,6 @@ import ofscraper.utils.context.exit as exit
 from ofscraper.classes.sessionmanager.download import download_session
 from ofscraper.commands.scraper.actions.utils.log import final_log, final_log_text
 from ofscraper.commands.scraper.actions.utils.paths.paths import setDirectoriesDate
-from ofscraper.commands.scraper.actions.utils.buffer import download_log_clear_helper
 
 from ofscraper.commands.scraper.actions.utils.workers import get_max_workers
 from ofscraper.utils.context.run_async import run
@@ -192,7 +191,7 @@ class metadataCommandManager(commmandManager):
                                 and avatar
                                 and settings.get_settings().userfirst
                             ):
-                                logging.getLogger("shared_other").warning(
+                                logging.getLogger("shared").warning(
                                     avatar_str.format(avatar=avatar)
                                 )
                             data.extend(
@@ -294,7 +293,6 @@ def metadata():
 
 @run
 async def process_dicts(username, model_id, medialist):
-    download_log_clear_helper()
     task1 = None
     with progress_utils.setup_metadata_progress_live():
         common_globals.mainProcessVariableInit()
@@ -337,7 +335,6 @@ async def process_dicts(username, model_id, medialist):
             common_globals.thread.shutdown()
 
         setDirectoriesDate()
-        download_log_clear_helper()
         progress_updater.remove_metadata_task(task1)
         final_log(username)
         return final_log_text(username)

{ofscraper-3.13.dev4 → ofscraper-3.13.dev6}/ofscraper/commands/scraper/actions/download/download.py

@@ -22,7 +22,6 @@ from ofscraper.classes.sessionmanager.download import download_session
 from ofscraper.commands.scraper.actions.utils.log import final_log, final_log_text
 
 from ofscraper.commands.scraper.actions.utils.paths.paths import setDirectoriesDate
-from ofscraper.commands.scraper.actions.utils.buffer import download_log_clear_helper
 
 from ofscraper.commands.scraper.actions.utils.workers import get_max_workers
 from ofscraper.utils.context.run_async import run
@@ -45,7 +44,7 @@ async def downloader(username=None, model_id=None, posts=None, media=None, **kwa
     )
 
     progress_updater.update_activity_task(description=download_str + path_str)
-    logging.getLogger("shared_other").warning(
+    logging.getLogger("shared").warning(
         download_activity_str.format(username=username)
     )
     progress_updater.update_activity_task(description="")
@@ -71,7 +70,6 @@ async def download_model_deleted_process(
 @run
 async def process_dicts(username, model_id, medialist, posts):
     log_text_array = []
-    download_log_clear_helper()
     log_text_array.append(await textDownloader(posts, username=username))
     logging.getLogger("shared").info("Downloading in single thread mode")
     common_globals.mainProcessVariableInit()
@@ -103,7 +101,6 @@ async def process_dicts(username, model_id, medialist, posts):
         try:
 
             aws = []
-
             async with download_session() as c:
                 for ele in medialist:
                     aws.append((c, ele, model_id, username))
@@ -139,7 +136,6 @@ async def process_dicts(username, model_id, medialist, posts):
             common_globals.thread.shutdown()
 
         setDirectoriesDate()
-        download_log_clear_helper()
         final_log(username, log=logging.getLogger("shared"))
         progress_updater.remove_download_task(task1)
         log_text_array.append(final_log_text(username))