fbcrawl 0.0.1__tar.gz

fbcrawl-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Securely Innovations
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fbcrawl-0.0.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: fbcrawl
+Version: 0.0.1
+Summary: A small example package
+Author-email: Farhan Ahmed <jattfarhan10@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Securely-Innovations/FbScraper
+Project-URL: Issues, https://github.com/Securely-Innovations/FbScraper/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

fbcrawl-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fbcrawl"
+version = "0.0.1"
+authors = [
+  { name="Farhan Ahmed", email="jattfarhan10@gmail.com" },
+]
+description = "A small example package"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/Securely-Innovations/FbScraper"
+Issues = "https://github.com/Securely-Innovations/FbScraper/issues"

fbcrawl-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fbcrawl-0.0.1/src/fbcrawl/auth.py

@@ -0,0 +1,65 @@
+import os
+from seleniumwire import webdriver
+from selenium.webdriver.common.by import By
+from selenium.common.exceptions import TimeoutException
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+
+class Authenticator:
+    def __init__(self, driver, email, password) -> None:
+        self.email = email
+        self.driver = driver
+        self.password = password
+        
+        self.xpaths = {
+            "create_post_btn": "//div[@aria-label='Create a post']"
+        }
+
+
+    def authenticate(self):
+        if self.is_logged_in():
+            print("[+] Already logged in (session restored)")
+            return
+        print("[*] Session not authenticated, logging in...")
+        self.perform_login()
+
+
+    def is_logged_in(self, timeout=5):
+        """
+        Detect whether Facebook session is already authenticated
+        """
+        try:
+            WebDriverWait(self.driver, timeout).until(
+                EC.presence_of_element_located((By.XPATH, self.xpaths['create_post_btn']))
+            )
+            return True
+        except TimeoutException:
+            return False
+
+
+    def perform_login(self):
+        """
+        Login using email/password if logged out
+        """
+        try:
+            email_field = WebDriverWait(self.driver, 10).until(
+                EC.presence_of_element_located((By.ID, "email"))
+            )
+            password_field = self.driver.find_element(By.ID, "pass")
+
+            email_field.clear()
+            email_field.send_keys(self.email)
+            password_field.clear()
+            password_field.send_keys(self.password)
+
+            login_button = self.driver.find_element(By.NAME, "login")
+            login_button.click()
+            input("Press Enter after completing any additional verification steps...")
+            WebDriverWait(self.driver, 15).until(
+                EC.presence_of_element_located((By.XPATH, self.xpaths['create_post_btn']))
+            )
+
+            print("[+] Logged in successfully")
+
+        except TimeoutException:
+            raise RuntimeError("[-] Login failed or Facebook UI changed")

fbcrawl-0.0.1/src/fbcrawl/drivers.py

@@ -0,0 +1,43 @@
+import os
+from seleniumwire import webdriver
+from selenium.webdriver.common.by import By
+from selenium.common.exceptions import TimeoutException
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+
+
+class Init:
+    def get_driver(self, profile_path: str = "", proxy: dict = {}) -> webdriver.Chrome:
+        """Initializes Selenium-wire driver instance
+
+        Args:
+            profile_path (str): Path to Store Chrome Profile, helps save auth session. By Default it saves a profile in current directory
+            proxy (dict): a proxy dict with following structure:     
+                "proxy": {
+                    "http": "http://username:password@host:port", 
+                    "https": "https://username:password@host:port",
+                    "no_proxy": "localhost,127.0.0.1"
+                }
+
+        Returns:
+            webdriver.Chrome: Selenium-wire driver Object
+        """
+        if not profile_path:
+            base_dir = os.getcwd()
+            profile_path = os.path.join(base_dir, "chrome_profile")
+
+        os.makedirs(profile_path, exist_ok=True)
+
+        options = webdriver.ChromeOptions()
+        options.add_argument(f"--user-data-dir={profile_path}")
+        options.add_argument("--profile-directory=Default")
+        options.add_argument("--disable-notifications")
+        # options.add_argument("--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36")
+        if proxy:
+            seleniumwire_options = {
+                'proxy': proxy
+            }
+            driver = webdriver.Chrome(options=options, seleniumwire_options=options)
+        else:
+            driver = webdriver.Chrome(options=options)
+        return driver

fbcrawl-0.0.1/src/fbcrawl/file_ops.py

@@ -0,0 +1,12 @@
+import os
+import json
+
+def load_json(json_path='posts.json'):
+    if not os.path.exists(json_path):
+        return {}
+    with open(json_path, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+def save_json(file_name, data):
+    with open(file_name, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=4, ensure_ascii=False)

fbcrawl-0.0.1/src/fbcrawl/request_parsers/comments.py

@@ -0,0 +1,203 @@
+
+import json
+from request_parsers.requests_decoder import get_response
+
+
+class CommentsParser:
+    def __init__(self, driver):
+        self.replies = {}
+        self.comments = {}
+        self.driver = driver
+        self.fetch_comments_api()
+
+    def fetch_comments(self):
+        # self.combine_replies_with_comments()
+        # post_id = None
+        # for comment_data in self.comments.values():
+        #     post_id = comment_data.get('post_id')
+        #     if post_id:
+        #         break
+        # if post_id is None:
+        #     return {}
+        return self.comments, self.replies
+
+    def fetch_comments_api(self):
+        for comments in get_response(self.driver, _type=['comments', 'replies']):
+            if comments.get('comments'):
+                total = f"{len(comments['comments'])} Comments"
+                self.comments |= self.parse_comments(comments['comments'])
+            else: # Comment Replies
+                total = f"{len(comments['replies'])} Replies"
+                self.replies |= self.parse_replies(comments['replies'])
+            print(f"Fetched {total}")
+
+    def parse_comments(self, edges):
+        comments = {}
+        for edge in edges:
+            comment = self.extract_comment_info(edge)
+            comments |= comment
+        return comments
+
+    def extract_comment_info(self, comment_edge: dict) -> dict:
+        """
+        Extracts important fields from a Facebook GraphQL comment edge.
+        """
+        node = comment_edge.get("node", {})
+        feedback = node.get("feedback", {})
+        feedback = {} if feedback is None else feedback
+        author = node.get("author", {})
+        body = node.get("body", {})
+        parent_feedback = node.get("parent_feedback", {})
+        if parent_feedback is None or parent_feedback == {}:
+            parent_feedback = node.get("comet_comment_author_name_and_badges_renderer", {}).get('comment', {}).get("parent_feedback", {})
+
+        attachments = []
+        tmp_attachments = node.get("attachments", [])
+        for tmp_attachment in tmp_attachments:
+            tmp = tmp_attachment.get('style_type_renderer', {}).get('attachment', {})
+            if tmp is None:
+                continue
+            media = tmp.get('media')
+            attachment = {
+                "type": media if media is None else media.get("__typename"),
+                "url": tmp.get("url"),
+                "photo_img": tmp.get('photo_image', {}).get('uri'),
+
+            }
+            attachments.append(attachment)
+        # Reaction breakdown
+        reactions = {}
+        for r in feedback.get("top_reactions", {}).get("edges", []):
+            reaction_id = r["node"].get("id")
+            reactions[reaction_id] = r.get("reaction_count", 0)
+        post_id = parent_feedback.get("share_fbid")
+        if post_id is None:
+            with open("debug_missing_post_id.json", "w", encoding="utf-8") as f:
+                json.dump(comment_edge, f, indent=4)
+            raise ValueError("Post ID not found in parent feedback.")
+        comment_id = node.get("id")
+        if comment_id is None:
+            with open("debug_missing_comment_id.json", "w", encoding="utf-8") as f:
+                json.dump(comment_edge, f, indent=4)
+            raise ValueError("Comment ID not found in comment node.")
+        extracted = {
+            # Comment identifiers
+            "id": comment_id,
+
+            # Author info
+            "author_id": author.get("id"),
+            "author_name": author.get("name"),
+            "author_profile_url": author.get("url"),
+            "author_gender": author.get("gender"),
+
+            # Content
+            "text": None if body is None else body.get("text"),
+            "language": node.get("translatability_for_viewer", {}).get("source_dialect"),
+
+            # Timing
+            "created_time": node.get("created_time"),
+
+            # Engagement
+            "reaction_total": feedback.get("reactors", {}).get("count"),
+            "reaction_breakdown": reactions,
+            "reply_count": feedback.get("replies_fields", {}).get("total_count"),
+
+            # Relationships
+            "post_id": post_id,
+            "post_author_id": parent_feedback.get("owning_profile", {}).get("id"),
+
+            # URLs
+            "comment_url": feedback.get("url"),
+            "attachements": attachments,
+            # Replies
+            "replies": {}
+        }
+        reply_edges = feedback.get("replies_connection", {}).get("edges", [])
+        if reply_edges:
+            replies = self.parse_replies(reply_edges)
+            self.replies |= replies
+
+        return {comment_id: extracted}
+
+    def extract_reply_info(self, edge: dict) -> dict:
+        node = edge.get("node", {})
+        author = node.get("author", {})
+        feedback = node.get("feedback", {})
+        body = node.get("body", {})
+        # Reaction breakdown
+        reactions = {}
+        for r in feedback.get("top_reactions", {}).get("edges", []):
+            reaction_id = r["node"].get("id")
+            reactions[reaction_id] = r.get("reaction_count", 0)
+
+        parent_comment_id = node.get("comment_direct_parent", {}).get("id")
+        if parent_comment_id is None:
+            with open("debug_missing_parent_comment_id.json", "w", encoding="utf-8") as f:
+                json.dump(edge, f, indent=4)
+            raise ValueError("Parent comment ID not found in reply.")
+        reply_id = node.get("id")
+        if reply_id is None:
+            with open("debug_missing_reply_id.json", "w", encoding="utf-8") as f:
+                json.dump(edge, f, indent=4, ensure_ascii=True)
+            raise ValueError("Reply ID not found in reply node.")
+        extracted = {
+            "id": reply_id,
+            "depth": node.get("depth"),
+
+            "author_id": author.get("id"),
+            "author_name": author.get("name"),
+            "author_profile": author.get("url"),
+            "author_gender": author.get("gender"),
+
+            "text": None if body is None else body.get("text"),
+            "language": node.get("translatability_for_viewer", {}).get("source_dialect"),
+
+            "created_time": node.get("created_time"),
+
+            "parent_comment_id": parent_comment_id,
+
+            "reply_count": feedback.get("replies_fields", {}).get("count"),
+            "reaction_count": feedback.get("reactors", {}).get("count"),
+            "reaction_breakdown": reactions,
+
+            "comment_url": feedback.get("url"),
+            "replies": {}
+        }
+        reply_edges = feedback.get("replies_connection", {}).get("edges", [])
+        if reply_edges:
+            replies = self.parse_replies(reply_edges)
+            self.replies |= replies
+
+        return {reply_id: extracted}
+
+
+    def parse_replies(self, edges: dict) -> dict:
+        replies = {}
+        for edge in edges:
+            reply = self.extract_reply_info(edge)
+            replies |= reply
+        return replies
+
+    def combine_replies_with_comments(self):
+            """
+            Combining replies to their respective parent comments and replies.
+            Supports multi-level nesting (comment -> reply -> sub-reply).
+            """
+            # 1. Create a unified lookup of everything that can be a parent
+            # This allows us to find a parent whether it is a top-level comment or a reply
+            all_nodes = {**self.comments, **self.replies}
+            print(f"Total comments: {len(self.comments)}, Total replies: {len(self.replies)}")
+            # 2. Iterate through all replies to find their parents
+            for reply_id, reply_data in self.replies.items():
+                parent_id = reply_data.get('parent_comment_id')
+
+                if parent_id and parent_id in all_nodes:
+                    # Add the reply to the 'replies' dictionary of its parent
+                    # Using the parent_id from all_nodes ensures we can nest deeply
+                    all_nodes[parent_id]['replies'][reply_id] = reply_data
+                else:
+                    # This case handles scenarios where a reply's parent might not 
+                    # have been captured in the current API fetch cycle
+                    print(f"Warning: Parent ID {parent_id} for reply {reply_id} not found.")
+            # self.comments is now updated in-place because objects in Python are passed by reference.
+            # Top-level comments now contain their direct replies, which contain their sub-replies.

fbcrawl-0.0.1/src/fbcrawl/request_parsers/posts.py

@@ -0,0 +1,203 @@
+
+import json
+import traceback
+from request_parsers.requests_decoder import get_response
+
+
+class PostParser:
+    def __init__(self, driver):
+        self.posts = {}
+        self.driver = driver
+
+    def fetch_post(self) -> dict:
+        return self.posts
+
+    def fetch_post_apis(self):
+        self.fetch_post_api('post')
+        self.fetch_post_api('posts')
+
+    def fetch_post_api(self, post_type: str ='post') -> None:
+        """Fetch data from post API
+
+        Args:
+            post_type (str, optional): There are two types of post data (post, posts). Defaults to 'post'.
+        """
+        for post in get_response(self.driver, _type=post_type):
+            data = self.extract_post_info(post['post'])
+            if data is None:
+                continue
+            self.posts[data['old_id']] = data
+
+    def _extract_attached_story(self, story: dict) -> dict:
+        """Cleans Post data from fb and return it.
+
+        Args:
+            story (dict): 
+
+        Returns:
+            dict: Clean Post Info
+        """
+        # Navigate to the main story object
+        if story is None or story == {}:
+            return {}
+        context_story = story.get("comet_sections", {}).get("context_layout", {}).get("story", {})
+        # 2. Text (Original)
+        content_story = context_story.get("comet_sections", {}).get("content", {}).get("story", {})
+        if content_story is None:
+            content_story = content_story
+        if content_story.get('message') is None:
+            original_text = None
+            translation_text = None
+        else:
+            original_text = content_story.get('message', {}).get('text')
+            # 3. Translation
+            message_container = content_story.get('comet_sections', {}).get('message_container', {})
+            translation_text = None if message_container is None else message_container.get('story', {}).get('translation', {}).get('message', {}).get('text')
+
+        # Extract Actor Info
+        actor = context_story.get("comet_sections", {}).get("title", {}).get("story", {}).get("actors", [{}])[0]
+        author_name = actor.get("name")
+        author_name = author_name if author_name is not None else story.get("feedback", {}).get("owning_profile", {}).get("name")
+        # Extract Metadata (Timestamp)
+        metadata = context_story.get("comet_sections", {}).get("metadata", [])
+        timestamp = None
+        if metadata:
+            timestamp = metadata[0].get("story", {}).get("creation_time")
+        data = {
+            "old_id": story.get("id"),
+            "id": story.get("feedback", {}).get("owning_profile", {}).get("id"),
+            "author": author_name,
+            "author_url": actor.get("url"),
+            "original_text": original_text,
+            "translation": translation_text,
+            "created_time": timestamp,
+            "post_link": story.get("permalink_url"),
+        }
+        
+        return data
+
+    def _extract_engagement_metrics(self, comet_sections: dict) -> dict:
+        """
+        Extract reactions, comments, and shares from Facebook Comet UFI block
+        as seen in del.json
+        """
+
+        feedback_root = (
+            comet_sections
+            .get("feedback", {})
+            .get("story", {})
+            .get("story_ufi_container", {})
+            .get("story", {})
+            .get("feedback_context", {})
+            .get("feedback_target_with_context", {})
+            .get("comet_ufi_summary_and_actions_renderer", {})
+            .get("feedback", {})
+        )
+
+        if not feedback_root:
+            return {"error": "No UFI feedback block found"}
+
+        # Total reactions
+        reactions_total = (
+            feedback_root
+            .get("reaction_count", {})
+            .get("count")
+        )
+
+        # Reaction breakdown (Like, Love, Haha, etc.)
+        reactions_breakdown = {}
+        for edge in feedback_root.get("top_reactions", {}).get("edges", []):
+            node = edge.get("node", {})
+            name = node.get("localized_name")
+            count = edge.get("reaction_count")
+            if name and count is not None:
+                reactions_breakdown[name] = count
+
+        # Total comments
+        comments_total = (
+            feedback_root
+            .get("comment_rendering_instance", {})
+            .get("comments", {})
+            .get("total_count")
+        )
+
+        # Total shares
+        shares_total = (
+            feedback_root
+            .get("share_count", {})
+            .get("count")
+        )
+
+        return {
+            "total_reactions": reactions_total,
+            "reactions_breakdown": reactions_breakdown,
+            "total_comments": comments_total,
+            "total_shares": shares_total,
+        }
+
+
+    def extract_post_info(self, story): # story=node_v2
+        try:        
+            # Access the main story node
+            comet_sections = story.get('comet_sections', {})
+            content_story = comet_sections.get('content', {}).get('story', {})
+            
+            # 1. IDs
+            post_id = story.get('post_id')
+            internal_id = story.get('id')
+            
+            # 2. Text (Original)
+            if content_story.get('message') is None:
+                original_text = None
+                translation_text = None
+            else:
+                original_text = content_story.get('message', {}).get('text')
+                # 3. Translation
+                message_container = content_story.get('comet_sections', {}).get('message_container', {})
+                translation_text = None if message_container is None else message_container.get('story', {}).get('translation', {}).get('message', {}).get('text')
+            
+            # 4. Timestamp
+            # Creation time is usually found in the metadata/timestamp section
+            timestamp = comet_sections.get('timestamp', {}).get('story',{}).get('creation_time')
+            # 5. Post Link
+            post_link = content_story.get('wwwURL')
+            
+            # 6. Author Info
+            author = content_story.get('actors', [{}])[0].get('name')
+            author_url = content_story.get('actors', [{}])[0].get('url')
+
+            # Attachments
+            attachments = []
+            tmp_attachments = story.get("attachments", [])
+            if tmp_attachments == [] and content_story is not None and content_story.get("attached_story", {}) is not None:
+                    tmp_attachments = content_story.get("attached_story", {}).get("attachments", [])
+            for tmp_attachment in tmp_attachments:
+                tmp = tmp_attachment.get('styles', {}).get('attachment', {}).get('media', {})
+                if tmp is None:
+                    continue
+                attachment = {
+                    "type": tmp.get("__typename"),
+                    "url": tmp.get("url"),
+                    "photo_img": tmp.get('photo_image', {}).get('uri'),
+                }
+                attachments.append(attachment)
+            data = {
+                "old_id": post_id,
+                "id": internal_id,
+                "author": author,
+                "author_url": author_url,
+                "original_text": original_text,
+                "translation": translation_text,
+                "created_time": timestamp,
+                "post_link": post_link,
+                "attachments": attachments,
+            }
+            data |= self._extract_engagement_metrics(comet_sections)
+            data["attached_story"] = self._extract_attached_story(story.get("attached_story", {}))
+            return data
+        except Exception as e:
+            print(f"Error extracting post info: {e}")
+            print(traceback.format_exc())
+            with open("debug_extract_post_error.json", "w", encoding="utf-8") as f:
+                json.dump(story, f, indent=4, ensure_ascii=False)
+            raise e

fbcrawl-0.0.1/src/fbcrawl/request_parsers/requests_decoder.py

@@ -0,0 +1,81 @@
+import chompjs
+from networkx import edges
+from seleniumwire.utils import decode
+
+
+def decode_response_body(response) -> dict | None:
+    """
+    Safely decode Selenium Wire response body into JSON.
+    Handles gzip / brotli / plain text.
+    """
+
+    body = response.body
+    decoded_json = decode(response.body,
+                        response.headers.get('Content-Encoding', 'identity')).decode(
+                        'utf-8')
+
+    chomped_json = chompjs.parse_js_object(decoded_json)
+    return chomped_json
+
+
+def get_response(driver, url: str="", _type: str="comments"):
+    """Returns decoded response of desired requests
+
+    Args:
+        driver (WebDriver): Selenium-wire WebDriver to get requests
+        url (str, optional): Urls to which response is required.
+        type (str, optional): Type of content required i.e ["comments", "post", "posts"]. Defaults to "comments".
+    """
+    allowed_types = ['post', 'posts', 'comment']
+    if _type not in allowed_types:
+        raise Exception(f"Invalid _type value {_type}. Allowed types are {', '.join(allowed_types)}")
+    # requests = driver.requests.copy()
+    for request in driver.requests:
+        if not request.response and "facebook.com/api/graphql" not in request.url:
+            continue
+        try:
+            response_json = decode_response_body(request.response)
+            if response_json is None:
+                continue
+        except Exception as e:
+            print("⚠️ Failed parsing JSON:", e)
+            continue
+        
+        if _type == 'post':
+            story = response_json.get('data', {}).get('node_v2', {})
+            if story:
+                print("Post data found in the response JSON.")
+                yield {'post': story}
+            else:
+                print("⚠️ post data not found in the response JSON.")
+
+        elif _type == 'posts':
+            edges = response_json.get("data", {}).get("node", {}).get("timeline_list_feed_units", {}).get("edges", [])
+            for edge in edges:
+                print("Post edges found in the response JSON.")
+                yield {'post': edge.get('node', {})}
+        elif _type == 'comments':
+            comments = (
+                response_json.get('data', {})
+                .get('node', {})
+                .get('comment_rendering_instance_for_feed_location', {})
+                .get('comments', {})
+                .get('edges', [])
+                )
+            replies = (
+                response_json.get("data", {})
+                .get("node", {})
+                .get("replies_connection", {})
+                .get("edges", [])
+            )
+
+            if not replies and not comments:
+                print("⚠️ Comments data not found in the response JSON.")
+
+            if comments:
+                print("Comments data found in the response JSON.")
+                yield {"comments": comments}
+            if replies:
+                print("Replies data found in the response JSON.")
+                yield {"replies": replies}
+    # del driver.requests[:len(requests)]

fbcrawl-0.0.1/src/fbcrawl/scraper.py

@@ -0,0 +1,55 @@
+from drivers import Init
+from auth import Authenticator
+from scrapers.post import PostScraper
+
+
+class FacebookScraper:
+    def __init__(self, email: str="", password: str="", profile_path: str="", output_path: str="posts.json", proxy: dict={}):
+        """ Initialize FacebookScraper Object and initialize the driver object.
+
+        Args:
+            email (str): Facebook Email
+            password (str): Account credentials
+            profile_path (str): Path to Store Chrome Profile, helps save auth session. By Default it saves a profile in current directory
+            
+            proxy (dict): The proxy should be in this format: 
+                {
+                    "http": "http://username:password@host:port", 
+                    "https": "https://username:password@host:port",
+                    "no_proxy": "localhost,127.0.0.1"
+                }
+            output_path (str): path to the json file that will contain the post data
+        """
+        self.output_path = output_path
+        self.driver = Init().get_driver(profile_path, proxy)
+        if email and password:
+            Authenticator(self.driver, email, password).authenticate()
+    
+    def authenticate(self, email, password):
+        Authenticator(self.driver, email, password).authenticate()
+
+
+    def get_profile(self, profile_url: str):
+        """Gets Profile data using profile url
+
+        Args:
+            profile_url (str): Facebook Profile URL
+        """
+        pass
+    
+    def get_post(self, post_url: str) -> None:
+        """Get Post by Post URL
+
+        Args:
+            post_url (str): url to facebook post
+        """
+        
+    def get_posts(self, profile_url: str, count: int=0):
+        """Scrape all posts of a profile
+
+        Args:
+            profile_url (str): Facebook Profile URL
+            count (int): Post count needed to be extracted, will get all posts if value is 0. Defaults to 0
+        """
+        scraper = PostScraper(self.driver, profile_url, self.output_path, count)
+        scraper.parse_feed()

fbcrawl-0.0.1/src/fbcrawl/scrapers/post.py

@@ -0,0 +1,78 @@
+import os
+import json
+import argparse
+import traceback  ### Don't remove this because we need it to fetches complete tracebacks on exceptions.
+from peewee import SqliteDatabase, Model, BigIntegerField, CharField, TextField, SmallIntegerField, BooleanField, IntegrityError, fn
+from time import sleep
+from initializer import Init
+from seleniumwire import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from time import sleep
+from selenium.webdriver.common.by import By
+from request_parsers.posts import PostParser
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.common.action_chains import ActionChains
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import (
+    WebDriverException, TimeoutException, 
+    StaleElementReferenceException, ElementClickInterceptedException
+)
+from file_ops import save_json, load_json
+
+
+class PostScraper:
+#----------------------------------------------Initializer--------------------------------------------#
+    def __init__(self, driver, profile_url, output_path, count) -> None:
+        self.count = count
+        self.driver = driver
+        self.profile_url = profile_url
+        self.output_path = output_path
+
+        self.post_data = load_json()
+        
+        self.open_profile()
+    
+    
+    def open_profile(self):
+        self.driver.get(self.profile_url)
+        self.wait_for_feed_load()
+
+    def wait_for_feed_load(self): # Bogus logic
+        try:
+            feed = WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.XPATH,
+                    "//div[@role='feed' and contains(., 'Other posts')]")))
+        except:
+            pass
+
+#---------------------------------------------------Post Interactors----------------------------------------------#
+    def parse_feed(self):
+        while True:
+            posts = WebDriverWait(self.driver, 20).until(EC.presence_of_all_elements_located((By.XPATH,
+                                                                                                "//div[@class='x1a2a7pz']")))
+            slider = self.driver.execute_script('return document.documentElement.scrollTop')
+            self.driver.execute_script('window.scrollTo(0, document.body.scrollHeight)')
+            print('Scrolling down')
+            sleep(3)
+            self.save_posts_data()
+            if slider == self.driver.execute_script('return document.documentElement.scrollTop'):
+                print('End of page')
+                break
+
+#------------------------------------------------- Parse and Save data---------------------------------------------------------#
+    def get_post_data(self):
+        parser = PostParser(self.driver)
+        parser.fetch_post_api('posts')
+        return parser.fetch_post()
+
+
+    def save_posts_data(self):
+        """Extracting date,name and text from posts. Comparing with old_data if exist"""
+        data = self.get_post_data()
+        if data == {}:
+            return 
+
+        self.posts_data |= data
+        save_json(self.output_path, self.posts_data)
+        print(f"Saved {len(self.post_data)} post")

fbcrawl-0.0.1/src/fbcrawl.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: fbcrawl
+Version: 0.0.1
+Summary: A small example package
+Author-email: Farhan Ahmed <jattfarhan10@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Securely-Innovations/FbScraper
+Project-URL: Issues, https://github.com/Securely-Innovations/FbScraper/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

fbcrawl-0.0.1/src/fbcrawl.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/fbcrawl/__init__.py
+src/fbcrawl/auth.py
+src/fbcrawl/drivers.py
+src/fbcrawl/file_ops.py
+src/fbcrawl/scraper.py
+src/fbcrawl.egg-info/PKG-INFO
+src/fbcrawl.egg-info/SOURCES.txt
+src/fbcrawl.egg-info/dependency_links.txt
+src/fbcrawl.egg-info/top_level.txt
+src/fbcrawl/request_parsers/__init__.py
+src/fbcrawl/request_parsers/comments.py
+src/fbcrawl/request_parsers/posts.py
+src/fbcrawl/request_parsers/requests_decoder.py
+src/fbcrawl/scrapers/post.py

fbcrawl-0.0.1/src/fbcrawl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fbcrawl-0.0.1/src/fbcrawl.egg-info/top_level.txt

@@ -0,0 +1 @@
+fbcrawl