ofscraper 3.10.dev1__tar.gz → 3.10.dev4__tar.gz

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ofscraper
-Version: 3.10.dev1
+Version: 3.10.dev4
 Summary: automatically scrape onlyfans
 Author: datawhores
 Author-email: datawhores@riseup.net

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/classes/sessionmanager.py

@@ -40,11 +40,13 @@ def is_rate_limited(exception):
 
 
 class SessionSleep:
-    def __init__(self, sleep=None):
-        self._sleep = sleep
-        self._init_sleep = sleep
+    def __init__(self, sleep=None,difmin=None):
+        self._sleep = None
+        self._init_sleep = sleep 
         self._last_date = arrow.now()
+        self._difmin=difmin if difmin!=None else constants.getattr("SESSION_SLEEP_INCREASE_TIME_DIFF")
         self._alock = asyncio.Lock()
+    
 
     def reset_sleep(self):
         self._sleep = self._init_sleep
@@ -56,13 +58,12 @@ class SessionSleep:
 
     def toomany_req(self):
         log = logging.getLogger("shared")
-        dif_min = constants.getattr("SESSION_SLEEP_INCREASE_TIME_DIFF")
-        if self._sleep is None:
-            self._sleep = constants.getattr("SESSION_SLEEP_INIT")
+        if not self._sleep:
+            self._sleep = self._init_sleep if self._init_sleep else constants.getattr("SESSION_SLEEP_INIT")
             log.debug(f"too many req => setting sleep to init [{self._sleep} seconds]")
-        elif arrow.now().float_timestamp - self._last_date.float_timestamp < dif_min:
+        elif arrow.now().float_timestamp - self._last_date.float_timestamp < self._difmin:
             log.debug(
-                f"too many req => not changing sleep [{self._sleep} seconds] because last call less than {dif_min} seconds"
+                f"too many req => not changing sleep [{self._sleep} seconds] because last call less than {self._difmin} seconds"
             )
             return self._sleep
         else:
@@ -357,6 +358,7 @@ class sessionManager:
                 except Exception as E:
                     if is_rate_limited(E):
                         sleeper.toomany_req()
+
                     log.traceback_(E)
                     log.traceback_(traceback.format_exc())
                     sync_sem.release()

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/commands/check.py

@@ -70,7 +70,7 @@ def process_item():
     try:
         row, key = table.row_queue.get()
     except Exception as E:
-        log.error(f"Error getting item from queue: {E}")
+        log.debug(f"Error getting item from queue: {E}")
         return
     for count, _ in enumerate(range(0, 2)):
         try:

ofscraper-3.10.dev4/ofscraper/commands/helpers/context.py

@@ -0,0 +1,147 @@
+import logging
+import traceback
+from itertools import chain
+
+
+
+import ofscraper.models.selector as selector
+import ofscraper.utils.args.helpers.areas as areas
+import ofscraper.utils.args.read as read_args
+import ofscraper.utils.constants as constants
+import ofscraper.utils.live.screens as progress_utils
+from ofscraper.commands.scraper.post import post_media_process
+
+from ofscraper.commands.helpers.strings import (
+    area_str,
+    avatar_str,
+    data_str,
+    progress_str,
+)
+log = logging.getLogger("shared")
+
+
+def get_user_action_function(func):
+    async def wrapper(userdata,session,*args, **kwargs):
+        async with session as c:
+            data=[]
+            for ele in userdata:
+                try:
+                    with progress_utils.setup_api_split_progress_live():
+                        all_media, posts, like_posts = await post_media_process(ele, c=c)
+                    with progress_utils.setup_activity_counter_live(revert=False):
+                        avatar = ele.avatar
+                        if (
+                            constants.getattr("SHOW_AVATAR")
+                            and avatar
+                            and read_args.retriveArgs ().userfirst
+                        ):
+                            logging.getLogger("shared_other").warning(avatar_str.format(avatar=avatar))
+                        data_helper(ele)
+                        data.append(await func(all_media, posts, like_posts,ele=ele))
+                except Exception as e:
+
+                    log.traceback_(f"failed with exception: {e}")
+                    log.traceback_(traceback.format_exc())
+
+                    if isinstance(e, KeyboardInterrupt):
+                        raise e
+                finally:
+                    progress_utils.increment_user_activity()
+            records=chain.from_iterable(data)
+            if len(records)<2:
+                return
+            for record in records:
+                log.warning(record)
+
+    return wrapper
+
+
+
+
+def get_userfirst_data_function(funct):
+    async def wrapper(userdata, session, *args, **kwargs):
+        progress_utils.update_activity_task(description="Getting all user data first")
+        progress_utils.update_user_activity(description="Users with Data Retrieved")
+        progress_utils.update_activity_count(description="Overall progress", total=2)
+        data = {}
+        async with session:
+            for ele in userdata:
+                try:
+                    data_helper(ele)
+                    with progress_utils.setup_activity_counter_live(revert=False):
+                        data.update(await funct(session, ele))
+                except Exception as e:
+                    log.traceback_(f"failed with exception: {e}")
+                    log.traceback_(traceback.format_exc())
+                    if isinstance(e, KeyboardInterrupt):
+                        raise e
+                finally:
+                    session.reset_sleep()
+                    progress_utils.increment_user_activity()
+        return data
+
+    return wrapper
+
+
+def get_userfirst_action_execution_function(funct):
+    async def wrapper(data,*args, **kwargs):
+        progress_utils.increment_activity_count(total=2)
+        try:
+             progress_utils.update_user_activity(total=len(data.items()))
+             for _, val in data.items():
+                all_media = val["media"]
+                posts = val["posts"]
+                like_posts = val["like_posts"]
+                ele = val["ele"]
+                avatar = ele.avatar
+                if (
+                    constants.getattr("SHOW_AVATAR")
+                    and avatar
+                    and read_args.retriveArgs().userfirst
+                ):
+                    logging.getLogger("shared_other").warning(avatar_str.format(avatar=avatar))
+                try:
+                    with progress_utils.setup_activity_counter_live(revert=False):
+                        await funct(all_media, posts, like_posts,*args, ele=ele,**kwargs)
+                except Exception as e:
+                    log.traceback_(f"failed with exception: {e}")
+                    log.traceback_(traceback.format_exc())
+                    if isinstance(e, KeyboardInterrupt):
+                        raise e
+                finally:
+                    progress_utils.increment_user_activity()
+        except Exception as e:
+            log.traceback_(f"failed with exception: {e}")
+            log.traceback_(traceback.format_exc())
+            if isinstance(e, KeyboardInterrupt):
+                raise e
+        finally:
+            progress_utils.increment_activity_count(description="Overall progress", total=2)
+
+    return wrapper
+
+
+
+def data_helper(user):
+    avatar = user.avatar
+    username = user.name
+    active = user.active
+    final_post_areas = areas.get_final_posts_area()
+    length = selector.get_num_selected()
+    count = progress_utils.get_user_task_obj().completed
+
+
+    logging.getLogger("shared_other").warning(
+        progress_str.format(count=count + 1, length=length)
+    )
+    logging.getLogger("shared_other").warning(data_str.format(name=username))
+    if constants.getattr("SHOW_AVATAR") and avatar:
+        logging.getLogger("shared_other").warning(avatar_str.format(avatar=avatar))
+    progress_utils.update_activity_task(
+        description=area_str.format(
+            areas=",".join(final_post_areas), name=username, active=active
+        )
+    )
+    logging.getLogger("shared_other").info(
+        area_str.format(areas=",".join(final_post_areas), name=username, active=active)
+    )

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/commands/manual.py

@@ -30,7 +30,7 @@ def manual_download(urls=None):
         network.check_cdm()
         allow_manual_dupes()
         url_dicts = process_urls(urls)
-        with progress_utils.setup_activity_live():
+        with progress_utils.setup_activity_progress_live():
             progress_utils.update_activity_task(
                 description="Getting data from retrived posts"
             )
@@ -51,7 +51,7 @@ def manual_download(urls=None):
             set_user_data(url_dicts)
 
         for _, value in url_dicts.items():
-            with progress_utils.setup_activity_live():
+            with progress_utils.setup_activity_progress_live():
                 model_id = value.get("model_id")
                 username = value.get("username")
                 model_id = value.get("model_id")

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/commands/metadata.py

@@ -32,7 +32,6 @@ import ofscraper.utils.live.screens as progress_utils
 import ofscraper.utils.profiles.tools as profile_tools
 from ofscraper.__version__ import __version__
 from ofscraper.commands.helpers.context import (
-    get_user_action_execution_function,
     get_user_action_function,
     get_userfirst_action_execution_function,
     get_userfirst_data_function,
@@ -53,7 +52,7 @@ log = logging.getLogger("shared")
 
 
 def metadata():
-    with progress_utils.setup_activity_live(stop=True):
+    with progress_utils.setup_activity_progress_live(stop=True):
         if read_args.retriveArgs().scrape_paid:
             progress_utils.update_activity_task(
                 description="Updating Metadata for  Entire Paid page"
@@ -189,8 +188,6 @@ async def execute_metadata_action_user_first(data):
             await get_user_action_execution_function(execute_metadata_action_on_user)(
                 media=media, user=ele
             )
-            # await download.download_process(username, model_id, filterMedia)
-            # metadata_stray_media(username, model_id, media)
         except Exception as e:
             if isinstance(e, KeyboardInterrupt):
                 raise e
@@ -251,7 +248,7 @@ def process_selected_areas():
     log.debug("[bold blue] Running Metadata Mode [/bold blue]")
     force_change_download()
     with scrape_context_manager():
-        with progress_utils.setup_activity_live(stop=True):
+        with progress_utils.setup_activity_progress_live(stop=True):
             if read_args.retriveArgs().metadata:
                 metadata()
 

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/commands/scraper/actions/download.py

@@ -31,7 +31,7 @@ async def downloader(ele=None, posts=None, media=None, **kwargs):
     username = ele.name
     progress_utils.update_activity_task(description=download_str.format(name=username))
     logging.getLogger("shared_other").warning(download_str.format(name=username))
-    await download.download_process(username, model_id, media, posts=posts)
+    return await download.download_process(username, model_id, media, posts=posts)
 
 
 @run

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/commands/scraper/actions/like.py

@@ -21,6 +21,9 @@ import ofscraper.utils.cache as cache
 import ofscraper.utils.constants as constants
 import ofscraper.utils.context.exit as exit
 import ofscraper.utils.live.screens as progress_utils
+from rich.markup import escape
+from rich.text import Text
+
 
 log = logging.getLogger("shared")
 like_str = "Performing Like Action on {name}"
@@ -35,7 +38,7 @@ def process_like(posts=None, model_id=None, task=None, username=None, **kwargs):
     unfavorited_posts = get_posts_for_like(posts)
     posts = pre_filter(posts)
     post_ids = get_post_ids(unfavorited_posts)
-    like(model_id, post_ids)
+    return like(model_id, username,post_ids)
 
 
 @exit.exit_wrapper
@@ -46,7 +49,7 @@ def process_unlike(posts=None, model_id=None, task=None, username=None, **kwargs
     favorited_posts = get_posts_for_unlike(posts)
     posts = pre_filter(posts)
     post_ids = get_post_ids(favorited_posts)
-    unlike(model_id, post_ids)
+    return unlike(model_id, username,post_ids)
 
 
 def get_posts_for_unlike(post):
@@ -82,15 +85,15 @@ def get_post_ids(posts: list) -> list:
     return list(map(lambda x: x.id, posts))
 
 
-def like(model_id, ids: list):
-    _like(model_id, ids, True)
+def like(model_id, username,ids: list):
+   return _like(model_id,username, ids, True)
 
 
-def unlike(model_id, ids: list):
-    _like(model_id, ids, False)
+def unlike(model_id,username, ids: list):
+    return _like(model_id, username,ids, False)
 
 
-def _like(model_id, ids: list, like_action: bool):
+def _like(model_id, username,ids: list, like_action: bool):
     like_str = (
         "Posts toggled from unlike to like...\n"
         if like_action
@@ -112,44 +115,67 @@ def _like(model_id, ids: list, like_action: bool):
 
             [tasks.append(functools.partial(like_func, c, id, model_id)) for id in ids]
             count = 1
+
+            stable_sleep_duration=constants.getattr("STABLE_SLEEP_DURATION_LIKE")
+            sleep_duration_50=constants.getattr("SLEEP_DURATION_LIKE_50")
+            sleep_duration_60=constants.getattr("SLEEP_DURATION_LIKE_60")
+            sleep_duration_common=constants.getattr("COMMON_MULTIPLE_SLEEP_DURATION_LIKE")
+
             for count, func in enumerate(tasks):
                 out = func()
                 if out == 0:
                     sleep_duration = 0
                 elif count + 1 % 60 == 0 and count + 1 % 50 == 0:
-                    sleep_duration = 40
+                    sleep_duration = sleep_duration_common
                 elif count % 60 == 0:
-                    sleep_duration = 1  # Divisible by 60 - 1 second sleep
+                    sleep_duration = sleep_duration_60  # Divisible by 60 - 1 second sleep
                 elif count % 50 == 0:
-                    sleep_duration = 30  # Divisible by 50 - 30 seconds sleep
+                    sleep_duration = sleep_duration_50   # Divisible by 50 - 30 seconds sleep
                 else:
-                    sleep_duration = 5
+                    sleep_duration =  stable_sleep_duration
                 if out == 1:
                     progress_utils.increment_like_task(task2)
                 progress_utils.increment_like_task(task)
                 time.sleep(sleep_duration)
+                title="Liked" if like_action else "Unliked"
+                liked=progress_utils.get_like_task(task2).completed
+                post=progress_utils.get_like_task(task).completed
+                action=title.lower()
+                text_out=f"[bold]\\[{username}][/bold] [bold]\\[Action {title}][/bold] ({post} post checked, {liked} post changes to {action})"
             progress_utils.remove_like_task(task)
-
+            progress_utils.remove_like_task(task2)
+    log.warning(text_out)
+    return text_out
 
 def _toggle_like_requests(c, id, model_id):
+
+
+    sleeper=sessionManager.SessionSleep(
+        sleep=constants.getattr("SESSION_429_SLEEP_STARTER_VAL"),
+        difmin=constants.getattr("SESSION_429_LIKE_INCREASE_SLEEP_TIME_DIF"),
+    )
     if not read_args.retriveArgs().force_like and cache.get(f"liked_status_{id}", None):
         log.debug(f"ID: {id} marked as liked in cache")
         return 0
-    sleep_duration = 5
-    favorited, id = _like_request(c, id, model_id)
+    sleep_duration = constants.getattr("DOUBLE_TOGGLE_SLEEP_DURATION_LIKE")
+    favorited, id = _like_request(c, id, model_id,sleeper)
     if favorited:
         log.debug(f"ID: {id} changed to liked")
         out = 1
     else:
         log.debug(f"ID: {id} restored to liked")
         time.sleep(sleep_duration)
-        _like_request(c, id, model_id)
+        _like_request(c, id, model_id,sleeper)
         out = 2
     cache.set(f"liked_status_{id}", True)
     return out
 
 
 def _toggle_unlike_requests(c, id, model_id):
+    sleeper=sessionManager.SessionSleep(
+        sleep=constants.getattr("SESSION_429_SLEEP_STARTER_VAL"),
+        difmin=constants.getattr("SESSION_429_LIKE_INCREASE_SLEEP_TIME_DIF")
+    )
     if (
         not read_args.retriveArgs().force_like
         and cache.get(f"liked_status_{id}", None) == False
@@ -157,22 +183,25 @@ def _toggle_unlike_requests(c, id, model_id):
         log.debug(f"ID: {id} marked as unliked in cache")
 
         return 0
-    sleep_duration = 5
-    favorited, id = _like_request(c, id, model_id)
+    sleep_duration = constants.getattr("DOUBLE_TOGGLE_SLEEP_DURATION_LIKE")
+    favorited, id = _like_request(c, id, model_id,sleeper)
     if not favorited:
         log.debug(f"ID: {id} changed to unliked")
         out = 1
     else:
         log.debug(f"ID: {id} restored to unlike")
         time.sleep(sleep_duration)
-        _like_request(c, id, model_id)
+        _like_request(c, id, model_id,sleeper)
         out = 2
     cache.set(f"liked_status_{id}", False)
     return out
 
 
-def _like_request(c, id, model_id):
+def _like_request(c, id, model_id,sleeper):
+   
     with c.requests(
-        constants.getattr("favoriteEP").format(id, model_id), method="post"
+        constants.getattr("favoriteEP").format(id, model_id),
+        method="post",sleeper=sleeper,
+        retries=constants.getattr("LIKE_MAX_RETRIES")
     ) as r:
         return r.json_()["isFavorite"], r.json_()["id"]

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/commands/scraper/runner.py

@@ -1,5 +1,4 @@
 import logging
-import traceback
 
 import ofscraper.api.init as init
 import ofscraper.classes.sessionmanager as sessionManager
@@ -14,11 +13,9 @@ import ofscraper.utils.context.exit as exit
 import ofscraper.utils.live.screens as progress_utils
 import ofscraper.utils.profiles.tools as profile_tools
 from ofscraper.commands.helpers.context import (
-    get_user_action_execution_function,
     get_user_action_function,
     get_userfirst_action_execution_function,
     get_userfirst_data_function,
-    user_first_data_inner_context,
 )
 from ofscraper.commands.helpers.shared import run_action_bool
 from ofscraper.commands.scraper.post import post_media_process
@@ -33,7 +30,7 @@ log = logging.getLogger("shared")
 def runner():
     check_auth()
     with scrape_context_manager():
-        with progress_utils.setup_activity_live(stop=True):
+        with progress_utils.setup_activity_group_live(setup=True,revert=False):
             if read_args.retriveArgs().scrape_paid:
                 progress_utils.update_activity_task(
                     description="Scraping Entire Paid page"
@@ -71,94 +68,62 @@ def prepare():
 @exit.exit_wrapper
 @run
 async def process_users_actions_normal(userdata=None, session=None):
-    user_action_funct = get_user_action_function(process_actions_for_user)
     progress_utils.update_user_activity(description="Users with Actions Completed")
-    async with session as c:
-        for ele in userdata:
-            await user_action_funct(user=ele, c=c)
+    await get_user_action_function( execute_user_action)(userdata,session)
 
 
-async def process_actions_for_user(user=None, c=None, *kwargs):
-    try:
-        all_media, posts, like_posts = await post_media_process(user, c=c)
-        await get_user_action_execution_function(execute_user_action)(
-            all_media, posts, like_posts, ele=user
-        )
-    except Exception as e:
-        if isinstance(e, KeyboardInterrupt):
-            raise e
-        log.traceback_(f"failed with exception: {e}")
-        log.traceback_(traceback.format_exc())
-
 
 async def execute_user_action(all_media, posts, like_posts, ele=None):
     actions = read_args.retriveArgs().action
     username = ele.name
     model_id = ele.id
+    out=[]
     for action in actions:
         if action == "download":
-            await download_action.downloader(
+            out.append(await download_action.downloader(
                 ele=ele,
                 posts=posts,
                 media=all_media,
                 model_id=model_id,
                 username=username,
-            )
+            ))
         elif action == "like":
-            like_action.process_like(
+            out.append(like_action.process_like(
                 ele=ele,
                 posts=like_posts,
                 media=all_media,
                 model_id=model_id,
                 username=username,
-            )
+            ))
         elif action == "unlike":
-            like_action.process_unlike(
+            out.append(like_action.process_unlike(
                 ele=ele,
                 posts=like_posts,
                 media=all_media,
                 model_id=model_id,
                 username=username,
-            )
+            ))
+        return out
 
 
 @exit.exit_wrapper
 @run
 async def process_users_actions_user_first(userdata, session):
-
     data = await get_userfirst_data_function(get_users_data_user_first)(
         userdata, session
     )
-
-    await get_userfirst_action_execution_function(execute_users_actions_user_first)(
-        data
-    )
-
-
-async def execute_users_actions_user_first(data):
     progress_utils.update_activity_task(description="Performing Actions on Users")
     progress_utils.update_user_activity(
         description="Users with Actions completed", completed=0
     )
-    for _, val in data.items():
-        all_media = val["media"]
-        posts = val["posts"]
-        like_posts = val["like_posts"]
-        ele = val["ele"]
-        await get_user_action_execution_function(execute_user_action)(
-            all_media, posts, like_posts, ele=ele
-        )
 
+    await get_userfirst_action_execution_function(execute_user_action)(
+        data
+    )
 
-async def get_users_data_user_first(session, ele):
-    try:
-        return await process_ele_user_first_data_retriver(ele, session)
-    except Exception as e:
-        if isinstance(e, KeyboardInterrupt):
-            raise e
-        log.traceback_(f"failed with exception: {e}")
-        log.traceback_(traceback.format_exc())
 
+async def get_users_data_user_first(session, ele):
+    return await process_ele_user_first_data_retriver(ele, session)
 
 async def process_ele_user_first_data_retriver(ele, session):
     model_id = ele.id

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/const/constants.py

@@ -25,3 +25,5 @@ from ofscraper.const.values.table import *
 from ofscraper.const.values.test_constants import *
 from ofscraper.const.values.time import *
 from ofscraper.const.values.url import *
+from ofscraper.const.values.like import *
+

ofscraper-3.10.dev4/ofscraper/const/values/like.py

@@ -0,0 +1,10 @@
+STABLE_SLEEP_DURATION_LIKE=5
+SLEEP_DURATION_LIKE_60=1
+SLEEP_DURATION_LIKE_50=30
+COMMON_MULTIPLE_SLEEP_DURATION_LIKE=40
+DOUBLE_TOGGLE_SLEEP_DURATION_LIKE=5
+SESSION_429_LIKE_INCREASE_SLEEP_TIME_DIF=0
+SESSION_429_SLEEP_STARTER_VAL=8
+LIKE_MAX_RETRIES=5
+
+

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/db/operations_/merge.py

@@ -71,7 +71,7 @@ async def batch_database_changes(new_root, old_root, user_dbs=None):
 
         except Exception as E:
             failures.append({"path": str(ele), "reason": E})
-            log.error(f"Issue getting required info for {ele}")
+            log.warning(f"Issue getting required info for {ele}")
             log.traceback_(E)
             log.traceback_(traceback.format_exc())
     log.info(

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/download/download.py

@@ -13,6 +13,7 @@ import ofscraper.utils.settings as settings
 import ofscraper.utils.system.system as system
 from ofscraper.download.shared.utils.text import textDownloader
 from ofscraper.utils.context.run_async import run
+from ofscraper.download.shared.utils.log import empty_log
 
 
 @run
@@ -26,10 +27,11 @@ async def download_process(username, model_id, medialist, posts=None):
 
 async def download_picker(username, model_id, medialist):
     if len(medialist) == 0:
+        out=empty_log(username)
         logging.getLogger("shared").error(
-            f"[bold]{username}[/bold] ({0} photos, {0} videos, {0} audios,  {0} skipped, {0} failed)"
+            out
         )
-        return 0, 0, 0, 0, 0
+        return out
     elif (
         system.getcpu_count() > 1
         and (
@@ -71,7 +73,4 @@ def download_post_process(username, model_id, medialist, postlist):
         log.traceback_(traceback.format_exc())
 
 
-def empty_log(username):
-    logging.getLogger("shared").error(
-        f"[bold]{username}[/bold] ({0} photos, {0} videos, {0} audios,  {0} skipped, {0} failed)"
-    )
+

{ofscraper-3.10.dev1 → ofscraper-3.10.dev4}/ofscraper/download/downloadbatch.py

@@ -36,7 +36,7 @@ from ofscraper.download.shared.common.general import (
     get_medialog,
     subProcessVariableInit,
 )
-from ofscraper.download.shared.utils.log import final_log, log_download_progress
+from ofscraper.download.shared.utils.log import final_log, final_log_text   ,log_download_progress
 from ofscraper.download.shared.utils.metadata import metadata
 from ofscraper.download.shared.utils.paths import addGlobalDir, setDirectoriesDate
 from ofscraper.download.shared.utils.progress import convert_num_bytes
@@ -51,7 +51,7 @@ def process_dicts(username, model_id, filtered_medialist):
     common_globals.log = log
     live = (
         partial(progress_utils.setup_download_progress_live, multi=True)
-        if not metadata_mode
+        if not metadata_md
         else partial(progress_utils.setup_metadata_progress_live)
     )
     try:
@@ -199,13 +199,7 @@ def process_dicts(username, model_id, filtered_medialist):
             with exit.DelayedKeyboardInterrupt():
                 raise E
     final_log(username)
-    return (
-        common_globals.photo_count,
-        common_globals.video_count,
-        common_globals.audio_count,
-        common_globals.forced_skipped,
-        common_globals.skipped,
-    )
+    return final_log_text(username)
 
 
 def queue_process(pipe_, task1, total):