ofscraper 3.10.dev2__tar.gz → 3.10.dev4__tar.gz

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

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

{ofscraper-3.10.dev2 → 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.dev2 → 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.dev2 → 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.dev2 → 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.dev2 → 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
@@ -134,8 +137,15 @@ def _like(model_id, ids: list, like_action: bool):
                     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):
 

{ofscraper-3.10.dev2 → 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.dev2 → ofscraper-3.10.dev4}/ofscraper/const/values/like.py

@@ -1,8 +1,3 @@
-
-
-
-
-
 STABLE_SLEEP_DURATION_LIKE=5
 SLEEP_DURATION_LIKE_60=1
 SLEEP_DURATION_LIKE_50=30

{ofscraper-3.10.dev2 → 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.dev2 → 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.dev2 → 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):

{ofscraper-3.10.dev2 → ofscraper-3.10.dev4}/ofscraper/download/downloadnormal.py

@@ -29,7 +29,7 @@ from ofscraper.download.alt_download import alt_download
 from ofscraper.download.main_download import main_download
 from ofscraper.download.shared.classes.session import download_session
 from ofscraper.download.shared.common.general import get_medialog
-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 setDirectoriesDate
 from ofscraper.download.shared.utils.progress import convert_num_bytes
@@ -39,12 +39,12 @@ from ofscraper.utils.context.run_async import run
 @run
 async def process_dicts(username, model_id, medialist):
 
-    metadata_mode = read_args.retriveArgs().metadata
+    metadata_md= read_args.retriveArgs().metadata
 
     # This need to be here: https://stackoverflow.com/questions/73599594/asyncio-works-in-python-3-10-but-not-in-python-3-8
     live = (
         partial(progress_utils.setup_download_progress_live, multi=False)
-        if not metadata_mode
+        if not metadata_md
         else partial(progress_utils.setup_metadata_progress_live)
     )
 
@@ -148,13 +148,8 @@ async def process_dicts(username, model_id, medialist):
             log_thread.join()
             other_thread.join() if other_thread else None
             final_log(username, log=logging.getLogger("shared"))
-            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)
+
 
         except Exception as E:
             with exit.DelayedKeyboardInterrupt():

{ofscraper-3.10.dev2 → ofscraper-3.10.dev4}/ofscraper/download/shared/utils/log.py

@@ -57,21 +57,30 @@ downloads total [{common_globals.video_count} videos, {common_globals.audio_coun
 
 
 def final_log(username, log=None):
+    (log or common_globals.log).error(
+            final_log_text(username)
+        )
+
+def final_log_text(username):
 
     if read_args.retriveArgs().metadata:
-        skipped_word = "media metadata unchanged"
-        (log or common_globals.log).error(
-            f"[bold]{username}[/bold] ({format_size(common_globals.total_bytes )}) ({common_globals.photo_count+common_globals.audio_count+common_globals.video_count}"
-            f" downloads total [{common_globals.video_count} videos, {common_globals.audio_count} audios, {common_globals.photo_count} photos], "
-            f"{common_globals.forced_skipped} {skipped_word}, {common_globals.skipped} failed)"
-        )
+        return (f"[bold]\\[{username}][/bold] [bold]\\[Action Download][/bold] ({format_size(common_globals.total_bytes )}) ({common_globals.photo_count+common_globals.audio_count+common_globals.video_count}"
+        f" downloads total [{common_globals.video_count} videos, {common_globals.audio_count} audios, {common_globals.photo_count} photos], "
+        f"{common_globals.forced_skipped} {skipped_word}, {common_globals.skipped} failed)")
     else:
         skipped_word = "skipped"
-        (log or common_globals.log).error(
-            f"[bold]{username}[/bold] ({format_size(common_globals.total_bytes )}) ({common_globals.photo_count+common_globals.audio_count+common_globals.video_count}"
-            f" downloads total [{common_globals.video_count} videos, {common_globals.audio_count} audios, {common_globals.photo_count} photos], "
-            f"{common_globals.forced_skipped} {skipped_word}, {common_globals.skipped} failed)"
-        )
+        return (f"[bold]\\[{username}][/bold] [bold]\\[Action Download][/bold] ({format_size(common_globals.total_bytes )}) ({common_globals.photo_count+common_globals.audio_count+common_globals.video_count}"
+        f" downloads total [{common_globals.video_count} videos, {common_globals.audio_count} audios, {common_globals.photo_count} photos], "
+        f"{common_globals.forced_skipped} {skipped_word}, {common_globals.skipped} failed)")
+
+
+def empty_log(username):
+    return f"[bold]\\[{username}][/bold] [bold]\\[Action Download][/bold] ({0} photos, {0} videos, {0} audios,  {0} skipped, {0} failed)"
+
+
+
+
+
 
 
 def text_log(username, value=0, fails=0, exists=0, log=None):

{ofscraper-3.10.dev2 → ofscraper-3.10.dev4}/ofscraper/filters/media/helpers.py

@@ -22,7 +22,7 @@ def sort_by_date(media):
     return sorted(media, key=lambda x: x.date)
 
 
-def dupefilter(media):
+def dupefilterMedia(media):
     output =defaultdict(lambda:None)
     for item in media:
         if not output[item.id]:
@@ -32,6 +32,15 @@ def dupefilter(media):
     return output.values()
 
 
+def dupefilterPost(post):
+    output =defaultdict(lambda:None)
+    for item in post:
+        if not output[item.id]:
+            output[item.id]=item
+        elif item.open and not output[item.id].open:
+             output[item.id]=item
+    return output.values()
+
 def post_datesorter(output):
     return list(sorted(output, key=lambda x: x.date, reverse=True))
 

{ofscraper-3.10.dev2 → ofscraper-3.10.dev4}/ofscraper/filters/media/main.py

@@ -69,7 +69,7 @@ def filterMedia(media, username=None, model_id=None):
 
     # additional filters
     if not read_args.retriveArgs().command == "metadata":
-        media = helpers.dupefilter(media)
+        media = helpers.dupefilterMedia(media)
         count += 1
         helpers.trace_log_media(count, media, "media dupe media_id filter:")
         log.debug(f"filter {count}->  media dupe media_id filter count: {len(media)}")
@@ -97,7 +97,7 @@ def filterPost(post):
     log.debug(f"filter {count}->  post date sort filter count: {len(post)}")
 
     count += 1
-    post = helpers.dupefilter(post)
+    post = helpers.dupefilterPost(post)
     helpers.trace_log_post(count, post, "post dupe filter:")
     log.debug(f"filter {count}-> post dupe filter count: {len(post)}")
 

{ofscraper-3.10.dev2 → ofscraper-3.10.dev4}/ofscraper/utils/console.py

@@ -28,7 +28,7 @@ def get_console():
 def get_shared_console():
     global shared_console
     if not shared_console:
-        shared_console = Console(theme=theme, quiet=quiet)
+        shared_console = Console(theme=theme, quiet=quiet,markup=True)
 
     return shared_console
 
@@ -36,7 +36,7 @@ def get_shared_console():
 def get_other_console():
     global other_console
     if not other_console:
-        other_console = Console(theme=theme)
+        other_console = Console(theme=theme,markup=True)
     return other_console
 
 

{ofscraper-3.10.dev2 → ofscraper-3.10.dev4}/ofscraper/utils/context/exit.py

@@ -82,7 +82,7 @@ class DelayedKeyboardInterrupt:
 def exit_wrapper(func):
     def inner(*args, **kwargs):
         try:
-            func(*args, **kwargs)
+            return func(*args, **kwargs)
         except KeyboardInterrupt:
             with DelayedKeyboardInterrupt():
                 raise KeyboardInterrupt