ofscraper 3.10.dev5__tar.gz → 3.10.dev6__tar.gz

{ofscraper-3.10.dev5 → ofscraper-3.10.dev6}/PKG-INFO

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

{ofscraper-3.10.dev5 → ofscraper-3.10.dev6}/ofscraper/commands/check.py

@@ -161,7 +161,7 @@ def post_checker():
 @run
 async def post_check_runner():
     async for user_name, model_id, final_post_array in post_check_retriver():
-        with progress_utils.setup_api_split_progress_live(stop=True):
+        with progress_utils.setup_api_split_progress_live(revert=True):
             progress_utils.update_activity_task(
                 description=check_str.format(
                     username=user_name, activity="Timeline posts"
@@ -331,7 +331,7 @@ def message_checker():
 @run
 async def message_checker_runner():
     async for user_name, model_id, final_post_array in message_check_retriver():
-        with progress_utils.setup_api_split_progress_live(stop=True):
+        with progress_utils.setup_api_split_progress_live(revert=True):
             progress_utils.update_activity_task(
                 description=check_str.format(username=user_name, activity="Messages")
             )
@@ -418,7 +418,7 @@ def purchase_checker():
 @run
 async def purchase_checker_runner():
     async for user_name, model_id, final_post_array in purchase_check_retriver():
-        with progress_utils.setup_api_split_progress_live(stop=True):
+        with progress_utils.setup_api_split_progress_live(revert=True):
             progress_utils.update_activity_task(
                 description=check_str.format(
                     username=user_name, activity="Purchased posts"
@@ -482,7 +482,7 @@ def stories_checker():
 @run
 async def stories_checker_runner():
     async for user_name, model_id, final_post_array in stories_check_retriver():
-        with progress_utils.setup_api_split_progress_live(stop=True):
+        with progress_utils.setup_api_split_progress_live(revert=True):
             progress_utils.update_activity_task(
                 description=check_str.format(
                     username=user_name, activity="Stories posts"

ofscraper-3.10.dev6/ofscraper/commands/helpers/data.py

@@ -0,0 +1,39 @@
+
+import logging
+
+import ofscraper.models.selector as selector
+import ofscraper.utils.args.helpers.areas as areas
+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 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.dev6/ofscraper/commands/helpers/final_log.py

@@ -0,0 +1,14 @@
+import logging
+import time
+import ofscraper.utils.constants as constants
+
+def final_log(data):
+    log = logging.getLogger("shared") 
+    if len(data)<3:
+        return
+    elif constants.getattr("SHOW_RESULTS_LOG"):
+        log.warning("[bold yellow]Final Results Logs[/bold yellow]")
+        for record in data:
+            log.warning(record)
+    #give time for last long to process
+    time.sleep(3)

ofscraper-3.10.dev6/ofscraper/commands/helpers/normal.py

@@ -0,0 +1,52 @@
+import logging
+import traceback
+
+
+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 (
+    avatar_str,
+)
+log = logging.getLogger("shared")
+from ofscraper.commands.helpers.data import data_helper
+
+
+def get_user_action_function(func):
+    async def wrapper(userdata,session,*args, **kwargs):
+        async with session as c:
+            data=["[bold yellow]Normal Mode Results[/bold yellow]"]
+            for ele in userdata:
+                try:
+                    with progress_utils.setup_api_split_progress_live():
+                        data_helper(ele)
+                        all_media, posts, like_posts = await post_media_process(ele, c=c)
+                    with progress_utils.setup_activity_group_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.extend(await func(media=all_media, posts=posts, like_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()
+            return data
+    return wrapper
+
+
+
+
+
+
+

ofscraper-3.10.dev6/ofscraper/commands/helpers/scrape_paid.py

@@ -0,0 +1,69 @@
+import logging
+
+import ofscraper.api.profile as profile
+import ofscraper.classes.models as models
+import ofscraper.commands.scraper.post as OF
+import ofscraper.download.download as download
+import ofscraper.models.selector as userselector
+import ofscraper.utils.live.screens as progress_utils
+from ofscraper.commands.helpers.strings import all_paid_download_str,metadata_activity_str, all_paid_progress_metadata_str
+
+from ofscraper.utils.context.run_async import run
+
+log = logging.getLogger("shared")
+
+@run
+async def process_scrape_paid():
+    progress_utils.update_activity_task(
+                    description="Scraping Entire Paid page"
+    )
+    with progress_utils.setup_all_paid_database_live():
+        async for ele in process_paid_dict():
+            yield ele
+        
+
+async def process_paid_dict():
+    user_dict = await OF.process_all_paid()
+    length = len(list(user_dict.keys()))
+    progress_utils.update_activity_count(totat=length, completed=0)
+
+
+    for count, value in enumerate(user_dict.values()):
+        yield count,value,length
+
+
+
+def process_user_info_printer(value,length,count,all_paid_activity=None,all_paid_update=None,log_progress=None):
+    model_id = value["model_id"]
+    username = value["username"]
+
+    all_paid_update=all_paid_update or all_paid_download_str
+    all_paid_activity=all_paid_activity or metadata_activity_str
+    log_progress=log_progress or all_paid_progress_metadata_str
+
+    progress_utils.update_activity_count(
+                totat=length,
+                description=all_paid_update.format(username=username),
+    )
+    progress_utils.update_activity_task(
+        description=(all_paid_activity.format(username=username,model_id=model_id,count=count+1,length=length)
+    ))
+    logging.getLogger("shared_other").warning(
+        log_progress.format(username=username,model_id=model_id,count=count+1,length=length)
+    )
+
+async def process_user(value,length):
+    model_id = value["model_id"]
+    username = value["username"]
+    posts = value["posts"]
+    medias = value["medias"]
+
+    userselector.set_ALL_SUBS_DICTVManger(
+        {
+            username: models.Model(
+                profile.scrape_profile(model_id, refresh=False)
+            )
+        }
+    )
+    progress_utils.increment_activity_count(total=length)
+    return (await download.download_process(username, model_id, medias, posts=posts))

{ofscraper-3.10.dev5 → ofscraper-3.10.dev6}/ofscraper/commands/helpers/shared.py

@@ -3,3 +3,8 @@ import ofscraper.utils.args.read as read_args
 
 def run_action_bool():
     return len(read_args.retriveArgs().action) > 0
+
+
+
+def run_metadata_bool():
+    return read_args.retriveArgs().metadata

{ofscraper-3.10.dev5 → ofscraper-3.10.dev6}/ofscraper/commands/helpers/strings.py

@@ -4,9 +4,18 @@ avatar_str = "Avatar : {avatar}"
 area_str = "Getting \[[bold blue]{areas}[/bold blue]] for [bold]{name}[/bold]\n[bold]Subscription Active:[/bold] {active}"
 all_paid_model_id_str = "getting username data for {model_id}"
 all_paid_str = "Creating databases for {username}"
-download_str = "Performing Downloading Action on {name}"
+download_activity_str = "Performing Downloading Action on {username}"
 all_paid_download_str = "Users With paid content downloaded"
-metadata_str = "Updating Metadata for {username}"
+all_paid_metadata_str = "Users With metadata updated downloaded"
+
+metadata_activity_str = "Updating Metadata for {username}"
+
 post_str_manual = "Manual Mode: Getting media from {url}"
 download_manual_str = "Downloading individual media for {username}"
 check_str = "Checking {activity} for {username}"
+
+all_paid_progress_download_str="[{model_id}_{username}] Downloading Progress :{count}/{length} models"
+
+all_paid_progress_metadata_str="[{model_id}_{username}] Metadata Update Progress :{count}/{length} models"
+
+mark_stray_str="Marking Stray Items for {username} as downloaded"

ofscraper-3.10.dev5/ofscraper/commands/helpers/context.py → ofscraper-3.10.dev6/ofscraper/commands/helpers/user_first.py

@@ -1,63 +1,17 @@
 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=list(chain.from_iterable(data))
-
-            if len(records)<2:
-                return
-            for record in records:
-                log.warning(record)
-
-    return wrapper
-
-
-
+from ofscraper.commands.helpers.data import data_helper
 
 def get_userfirst_data_function(funct):
     async def wrapper(userdata, session, *args, **kwargs):
@@ -86,6 +40,7 @@ def get_userfirst_data_function(funct):
 
 def get_userfirst_action_execution_function(funct):
     async def wrapper(data,*args, **kwargs):
+        out=["[bold yellow]User First Results[/bold yellow]"]
         progress_utils.increment_activity_count(total=2)
         try:
              progress_utils.update_user_activity(total=len(data.items()))
@@ -103,7 +58,7 @@ def get_userfirst_action_execution_function(funct):
                     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)
+                        out.extend(await funct(posts, like_posts,*args,media=all_media, ele=ele,**kwargs))
                 except Exception as e:
                     log.traceback_(f"failed with exception: {e}")
                     log.traceback_(traceback.format_exc())
@@ -118,31 +73,6 @@ def get_userfirst_action_execution_function(funct):
                 raise e
         finally:
             progress_utils.increment_activity_count(description="Overall progress", total=2)
-
+        return out
     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.dev5 → ofscraper-3.10.dev6}/ofscraper/commands/metadata.py

@@ -10,7 +10,6 @@
 (_______)|/              \_______)(_______/|/   \__/|/     \||/       (_______/|/   \__/
                                                                                       
 """
-
 import copy
 import logging
 import traceback
@@ -18,8 +17,6 @@ import traceback
 import arrow
 
 import ofscraper.api.init as init
-import ofscraper.api.profile as profile
-import ofscraper.classes.models as models
 import ofscraper.classes.sessionmanager as sessionManager
 import ofscraper.db.operations as operations
 import ofscraper.download.download as download
@@ -31,14 +28,17 @@ import ofscraper.utils.constants as constants
 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 (
+from ofscraper.commands.helpers.normal import (
     get_user_action_function,
+)
+from ofscraper.commands.helpers.user_first import (
     get_userfirst_action_execution_function,
     get_userfirst_data_function,
 )
-from ofscraper.commands.helpers.shared import run_action_bool
-from ofscraper.commands.helpers.strings import avatar_str, metadata_str
-from ofscraper.commands.scraper.post import process_all_paid, process_areas_helper
+from ofscraper.commands.helpers.shared import run_metadata_bool
+from ofscraper.commands.helpers.strings import metadata_activity_str,mark_stray_str,all_paid_metadata_str,all_paid_progress_metadata_str
+
+from ofscraper.commands.scraper.post import process_areas_helper
 from ofscraper.commands.scraper.scrape_context import scrape_context_manager
 from ofscraper.db.operations_.media import (
     batch_set_media_downloaded,
@@ -47,30 +47,35 @@ from ofscraper.db.operations_.media import (
     get_timeline_media,
 )
 from ofscraper.utils.context.run_async import run
-
+from ofscraper.commands.helpers.final_log import final_log
+from ofscraper.commands.helpers.scrape_paid import process_scrape_paid,process_user_info_printer,process_user
 log = logging.getLogger("shared")
 
 
 def metadata():
-    with progress_utils.setup_activity_progress_live(stop=True):
+    with progress_utils.setup_activity_progress_live(revert=True):
+        scrape_paid_data=[]
+        userfirst_data=[]
+        normal_data=[]
         if read_args.retriveArgs().scrape_paid:
-            metadata_paid_all()
-        if not run_action_bool():
-            return
-        userdata, session = prepare()
-        if not read_args.retriveArgs().users_first:
-            process_users_metadata_normal(userdata, session)
+            scrape_paid_data=metadata_paid_all()
+        if not run_metadata_bool():
+            pass
+        
+        elif not read_args.retriveArgs().users_first:
+            userdata, session = prepare()
+            normal_data=process_users_metadata_normal(userdata, session)
         else:
-            metadata_user_first(userdata, session)
+            userdata, session = prepare()
+            userfirst_data=metadata_user_first(userdata, session)
+    final_log(normal_data+scrape_paid_data+userfirst_data)
 
 
 @run
 async def process_users_metadata_normal(userdata, session):
-    user_action_funct = get_user_action_function(process_metadata_for_user)
-    progress_utils.update_activity_count(description="Users with Updated Metadata")
-    async with session:
-        for ele in userdata:
-            await user_action_funct(user=ele, session=session)
+    user_action_funct = get_user_action_function(execute_metadata_action_on_user)
+    progress_utils.update_user_activity(description="Users with Updated Metadata")
+    return await user_action_funct(userdata, session)
 
 
 @run
@@ -78,43 +83,38 @@ async def metadata_user_first(userdata, session):
     data = await get_userfirst_data_function(metadata_data_user_first)(
         userdata, session
     )
+    progress_utils.update_activity_task(description="Changing Metadata for Users")
+    progress_utils.update_user_activity(
+        description="Users with Metadata Changed", completed=0
+    )
 
-    await get_userfirst_action_execution_function(execute_metadata_action_user_first)(
+    return await get_userfirst_action_execution_function( execute_metadata_action_on_user)(
         data
     )
 
-
-def metadata_paid_all(user_dict=None):
-    progress_utils.update_activity_task("Scraping Entire Paid page")
+@run
+async def metadata_paid_all():
     old_args = copy.deepcopy(read_args.retriveArgs())
     force_change_metadata()
-    user_dict = process_all_paid()
-    oldUsers = userselector.get_ALL_SUBS_DICT()
-    length = len(list(user_dict.keys()))
-    for count, value in enumerate(user_dict.values()):
-        model_id = value["model_id"]
-        username = value["username"]
-        posts = value["posts"]
-        medias = value["medias"]
-        avatar = value["avatar"]
-        if constants.getattr("SHOW_AVATAR") and avatar:
-            logging.getLogger("shared_other").warning(avatar_str.format(avatar=avatar))
-        log.warning(
-            f"Download paid content for {model_id}_{username} number:{count+1}/{length} models "
-        )
-        userselector.set_ALL_SUBS_DICTVManger(
-            {username: models.Model(profile.scrape_profile(model_id))}
-        )
-        download.download_process(username, model_id, medias, posts=posts)
-    # restore settings
-    userselector.set_ALL_SUBS_DICT(oldUsers)
+    out=["[bold yellow]Scrape Paid Results[/bold yellow]"]
+
+    async for count,value,length in process_scrape_paid():
+        process_user_info_printer(value,length,count,all_paid_update=all_paid_metadata_str,all_paid_activity=metadata_activity_str,
+        log_progress=all_paid_progress_metadata_str
+
+                                  
+                                  )
+        out.append(await process_user(value,length))
     write_args.setArgs(old_args)
+    return out
+
 
 
 def metadata_stray_media(username, model_id, media):
     all_media = []
     curr_media_set = set(map(lambda x: str(x.id), media))
     args = read_args.retriveArgs()
+    progress_utils.update_activity_task(description=mark_stray_str.format(username=username))
     if "Timeline" in args.download_area:
         all_media.extend(get_timeline_media(model_id=model_id, username=username))
     if "Messages" in args.download_area:
@@ -138,59 +138,20 @@ def metadata_stray_media(username, model_id, media):
     batch_set_media_downloaded(filtered_media, model_id=model_id, username=username)
 
 
-async def process_metadata_for_user(user=None, session=None):
-    try:
-
-        model_id = user.id
-        all_media, _, _ = await process_areas_helper(user, model_id, c=session)
-        await get_user_action_execution_function(execute_metadata_action_on_user)(
-            user=user, media=all_media
-        )
-    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_metadata_action_on_user(user=None, media=None):
-    username = user.name
+async def execute_metadata_action_on_user(*args,ele=None, media=None,**kwargs):
+    username = ele.name
 
-    model_id = user.id
-    operations.table_init_create(model_id=model_id, username=username)
+    model_id = ele.id
+    await operations.table_init_create(model_id=model_id, username=username)
     filterMedia = filters.filterMedia(media, username=username, model_id=model_id)
     progress_utils.update_activity_task(
-        description=metadata_str.format(username=username)
+        description=metadata_activity_str.format(username=username)
     )
-    await download.download_process(username, model_id, filterMedia)
+    data=await download.download_process(username, model_id, filterMedia)
     metadata_stray_media(username, model_id, media)
+    return [data]
 
 
-async def execute_metadata_action_user_first(data):
-    progress_utils.update_activity_task(
-        description="Performing Metadata Actions on Users"
-    )
-    progress_utils.update_user_activity(
-        description="Users with Metadata updated", completed=0
-    )
-    for model_id, val in data.items():
-        username = val["username"]
-        media = val["media"]
-        ele = val["ele"]
-        progress_utils.update_activity_task(
-            description=metadata_str.format(username=username)
-        )
-        try:
-
-            await get_user_action_execution_function(execute_metadata_action_on_user)(
-                media=media, user=ele
-            )
-        except Exception as e:
-            if isinstance(e, KeyboardInterrupt):
-                raise e
-            log.traceback_(f"failed with exception: {e}")
-            log.traceback_(traceback.format_exc())
-
 
 @run
 async def metadata_data_user_first(session, ele):
@@ -231,6 +192,8 @@ async def process_ele_user_first_data_retriver(ele=None, session=None):
                 "media": media,
                 "avatar": avatar,
                 "ele": ele,
+                "posts":[],
+                "like_posts":[]
             }
         }
     except Exception as e:
@@ -244,10 +207,10 @@ async def process_ele_user_first_data_retriver(ele=None, session=None):
 def process_selected_areas():
     log.debug("[bold blue] Running Metadata Mode [/bold blue]")
     force_change_download()
+    progress_utils.update_activity_task(description="Running Metadata Mode")
     with scrape_context_manager():
-        with progress_utils.setup_activity_progress_live(stop=True):
-            if read_args.retriveArgs().metadata:
-                metadata()
+        with progress_utils.setup_activity_group_live(revert=True):
+            metadata()
 
 
 def prepare():

ofscraper-3.10.dev6/ofscraper/commands/scraper/actions/download.py

@@ -0,0 +1,61 @@
+r"""_____  _______         _______  _______  _______  _______  _______  _______  _______ 
+(  ___  )(  ____ \       (  ____ \(  ____ \(  ____ )(  ___  )(  ____ )(  ____ \(  ____ )
+| (   ) || (    \/       | (    \/| (    \/| (    )|| (   ) || (    )|| (    \/| (    )|
+| |   | || (__     _____ | (_____ | |      | (____)|| (___) || (____)|| (__    | (____)|
+| |   | ||  __)   (_____)(_____  )| |      |     __)|  ___  ||  _____)|  __)   |     __)
+| |   | || (                   ) || |      | (\ (   | (   ) || (      | (      | (\ (   
+| (___) || )             /\____) || (____/\| ) \ \__| )   ( || )      | (____/\| ) \ \__
+(_______)|/              \_______)(_______/|/   \__/|/     \||/       (_______/|/   \__/
+"""
+
+import logging
+import time
+
+import ofscraper.classes.placeholder as placeholder
+import ofscraper.download.download as download
+import ofscraper.utils.constants as constants
+import ofscraper.utils.live.screens as progress_utils
+from ofscraper.commands.helpers.strings import  download_activity_str,all_paid_progress_download_str,all_paid_download_str
+from ofscraper.commands.helpers.scrape_paid import process_scrape_paid,process_user_info_printer,process_user
+from ofscraper.utils.context.run_async import run
+
+
+log = logging.getLogger("shared")
+
+
+async def downloader(ele=None, posts=None, media=None, **kwargs):
+    model_id = ele.id
+    username = ele.name
+    progress_utils.update_activity_task(description=download_activity_str.format(username=username))
+    logging.getLogger("shared_other").warning(download_activity_str.format(username=username))
+    return await download.download_process(username, model_id, media, posts=posts)
+
+
+
+
+
+def unique_name_warning():
+    if not placeholder.check_uniquename():
+        log.warning(
+            "[red]Warning: Your generated filenames may not be unique\n \
+            https://of-scraper.gitbook.io/of-scraper/config-options/customizing-save-path#warning[/red]      \
+            "
+        )
+        time.sleep(constants.getattr("LOG_DISPLAY_TIMEOUT") * 3)
+
+@run
+async def scrape_paid_all():
+    out=["[bold yellow]Scrape Paid Results[/bold yellow]"]
+
+    async for count,value,length in process_scrape_paid():
+        process_user_info_printer(value,length,count,all_paid_update=all_paid_download_str,all_paid_activity=download_activity_str,
+        log_progress=all_paid_progress_download_str
+        )
+        out.append(await process_user(value,length))
+    return out
+
+
+
+
+    # progress_utils.update_activity_task(description="Downloading Paid Content")
+    # return process_scrape_paid(download_progress_message=download_activity_str,log_progress_message=all_paid_progress_download_str)