feat: add support for Firefox browser compatibility

config.py

@@ -1,6 +1,7 @@
 # In this file, you can set the configurations of the app.
 
 from constants import DEBUG
+from src.webdrivers.base_browser import BrowserType
 
 #config related to logging must have prefix LOG_
 LOG_LEVEL = DEBUG
@@ -11,4 +12,5 @@
 MINIMUM_WAIT_TIME_IN_SECONDS = 60
 
 JOB_APPLICATIONS_DIR = "job_applications"
-JOB_SUITABILITY_SCORE = 7
+JOB_SUITABILITY_SCORE = 7
+BROWSER_TYPE_CONFIG = BrowserType.CHROME

main.py

@@ -5,13 +5,12 @@
 import yaml
 import click
 from selenium import webdriver
-from selenium.webdriver.chrome.service import Service as ChromeService
-from webdriver_manager.chrome import ChromeDriverManager
 from selenium.common.exceptions import WebDriverException
 from lib_resume_builder_AIHawk import Resume, FacadeManager, ResumeGenerator, StyleManager
 from typing import Optional
-from src.utils.chrome_utils import chrome_browser_options
 
+from src.webdrivers.base_browser import BrowserType
+from src.webdrivers.browser_factory import BrowserFactory
 from src.job_application_profile import JobApplicationProfile
 from src.logging import logger
 
@@ -156,11 +155,9 @@ def file_paths_to_dict(resume_file: Path | None, plain_text_resume_file: Path) -
 
         return result
 
-def init_browser() -> webdriver.Chrome:
+def init_browser(browser_type: BrowserType = BrowserType.CHROME) -> webdriver.Chrome | webdriver.Firefox:
     try:
-        options = chrome_browser_options()
-        service = ChromeService(ChromeDriverManager().install())
-        return webdriver.Chrome(service=service, options=options)
+        return BrowserFactory.get_driver(browser_type)
     except Exception as e:
         raise RuntimeError(f"Failed to initialize browser: {str(e)}")
 
@@ -179,7 +176,7 @@ def create_and_run_bot(parameters, llm_api_key):
 
         job_application_profile_object = JobApplicationProfile(plain_text_resume)
 
-        browser = init_browser()
+        browser = init_browser(BrowserFactory.get_browser_type())
         login_component = get_authenticator(driver=browser, platform='linkedin')
         apply_component = AIHawkJobManager(browser)
         gpt_answerer_component = GPTAnswerer(parameters, llm_api_key)
@@ -214,7 +211,8 @@ def main(collect: bool = False, resume: Optional[Path] = None):
         parameters['uploads'] = FileManager.file_paths_to_dict(resume, plain_text_resume_file)
         parameters['outputFileDirectory'] = output_folder
         parameters['collectMode'] = collect
-
+        # check if the config is not set as well
+
         create_and_run_bot(parameters, llm_api_key)
     except ConfigError as ce:
         logger.error(f"Configuration error: {str(ce)}")

src/ai_hawk/job_manager.py

@@ -4,7 +4,6 @@
 import time
 from itertools import product
 from pathlib import Path
-from turtle import color
 
 from inputimeout import inputimeout, TimeoutOccurred
 from selenium.common.exceptions import NoSuchElementException

src/webdrivers/base_browser.py

@@ -0,0 +1,73 @@
+import os
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from loguru import logger
+
+
+class BrowserType(Enum):
+    """Enum for supported browser types"""
+    CHROME = "chrome"
+    FIREFOX = "firefox"
+
+class BrowserProfile:
+    """Manages browser profile creation and configuration"""
+    def __init__(self, browser_type: BrowserType):
+        self.browser_type: BrowserType = browser_type.name.lower()
+        self.profile_path = os.path.join(
+            os.getcwd(),
+            f"{self.browser_type}_profile",
+            "linkedin_profile"
+        )
+
+    def ensure_profile_exists(self) -> str:
+        """
+        Ensures the browser profile directory exists
+        Returns: Path to the profile directory
+        """
+        logger.debug(f"Ensuring {self.browser_type} profile exists at path: {self.profile_path}")
+        profile_dir = os.path.dirname(self.profile_path)
+
+        if not os.path.exists(profile_dir):
+            os.makedirs(profile_dir)
+            logger.debug(f"Created directory for {self.browser_type} profile: {profile_dir}")
+
+        if not os.path.exists(self.profile_path):
+            os.makedirs(self.profile_path)
+            logger.debug(f"Created {self.browser_type} profile directory: {self.profile_path}")
+
+        return self.profile_path
+
+class Browser(ABC):
+    """Abstract base class for browser implementations"""
+    def __init__(self):
+        self.profile = BrowserProfile(self.browser_type)
+
+    @property
+    def browser_type(self) -> str:
+        """Return the browser type identifier"""
+        return self.__class__.browser_type
+
+    @abstractmethod
+    def create_options(self):
+        """Create and return browser-specific options"""
+
+    @abstractmethod
+    def create_service(self):
+        """Create and return browser-specific service"""
+
+    def create_driver(self):
+        """Create and return browser-specific WebDriver instance"""
+        try:
+            options = self.create_options()
+            service = self.create_service()
+            driver = self._create_driver_instance(service, options)
+            logger.debug(f"{self.browser_type} WebDriver instance created successfully")
+            return driver
+        except Exception as e:
+            logger.error(f"Failed to create {self.browser_type} WebDriver: {e}")
+            raise RuntimeError(f"Failed to initialize {self.browser_type} browser: {str(e)}")
+
+    @abstractmethod
+    def _create_driver_instance(self, service, options):
+        """Create the specific driver instance"""

src/webdrivers/browser_factory.py

@@ -0,0 +1,43 @@
+from typing import Union
+
+from selenium import webdriver
+from loguru import logger
+
+from config import BROWSER_TYPE_CONFIG
+from src.webdrivers.base_browser import BrowserType
+
+
+class BrowserFactory:
+    """Factory class for creating browser instances"""
+    _browser_type: BrowserType = BROWSER_TYPE_CONFIG
+
+    @classmethod
+    def get_browser_type(cls) -> BrowserType:
+        """Get current browser type"""
+        return cls._browser_type
+
+    @classmethod
+    def set_browser_type(cls, browser_type: BrowserType) -> None:
+        """Set browser type"""
+        if browser_type not in BrowserType.__members__:
+            raise ValueError(f"Unsupported browser type: {browser_type}")
+        cls._browser_type = browser_type
+        logger.debug(f"Browser type set to: {browser_type}")
+
+    @classmethod
+    def get_driver(cls, browser_type: BrowserType) -> Union[webdriver.Chrome, webdriver.Firefox]:
+        """
+        Create and return a WebDriver instance for the specified browser type
+        Args:
+            browser_type: BrowserType enum value
+        Returns:
+            WebDriver instance
+        Raises:
+            RuntimeError: If browser initialization fails
+        """
+        browser_class = browser_type.value
+        if not browser_class:
+            raise ValueError(f"Unsupported browser type: {browser_type}")
+
+        browser = browser_class()
+        return browser.create_driver()

src/webdrivers/chrome.py

@@ -0,0 +1,59 @@
+import os
+from loguru import logger
+from selenium import webdriver
+from selenium.webdriver.chrome.service import Service as ChromeService
+from webdriver_manager.chrome import ChromeDriverManager
+
+from src.webdrivers.base_browser import Browser, BrowserType
+
+chromeProfilePath = os.path.join(os.getcwd(), "chrome_profile", "linkedin_profile")
+
+class Chrome(Browser):
+    """Chrome browser implementation"""
+    browser_type: BrowserType = BrowserType.CHROME
+
+    def create_options(self) -> webdriver.ChromeOptions:
+        """Create Chrome-specific options"""
+        self.profile.ensure_profile_exists()
+        options = webdriver.ChromeOptions()
+
+        chrome_arguments = [
+            "--start-maximized", "--no-sandbox", "--disable-dev-shm-usage",
+            "--ignore-certificate-errors", "--disable-extensions", "--disable-gpu",
+            "window-size=1200x800", "--disable-background-timer-throttling",
+            "--disable-backgrounding-occluded-windows", "--disable-translate",
+            "--disable-popup-blocking", "--no-first-run", "--no-default-browser-check",
+            "--disable-logging", "--disable-autofill", "--disable-plugins",
+            "--disable-animations", "--disable-cache"
+        ]
+
+        for arg in chrome_arguments:
+            options.add_argument(arg)
+
+        options.add_experimental_option("excludeSwitches", ["enable-automation", "enable-logging"])
+
+        prefs = {
+            "profile.default_content_setting_values.images": 2,
+            "profile.managed_default_content_settings.stylesheets": 2,
+        }
+        options.add_experimental_option("prefs", prefs)
+
+        if self.profile.profile_path:
+            initial_path = os.path.dirname(self.profile.profile_path)
+            profile_dir = os.path.basename(self.profile.profile_path)
+            options.add_argument('--user-data-dir=' + initial_path)
+            options.add_argument("--profile-directory=" + profile_dir)
+            logger.debug(f"Using Chrome profile directory: {self.profile.profile_path}")
+        else:
+            options.add_argument("--incognito")
+            logger.debug("Using Chrome in incognito mode")
+
+        return options
+
+    def create_service(self) -> ChromeService:
+        """Create Chrome-specific service"""
+        return ChromeService(ChromeDriverManager().install())
+
+    def _create_driver_instance(self, service, options):
+        """Create Chrome WebDriver instance"""
+        return webdriver.Chrome(service=service, options=options)

src/webdrivers/firefox.py

@@ -0,0 +1,57 @@
+import os
+
+from loguru import logger
+from selenium import webdriver
+from selenium.webdriver.firefox.service import Service as FirefoxService
+from webdriver_manager.firefox import GeckoDriverManager
+
+from src.webdrivers.base_browser import Browser, BrowserType
+
+firefoxProfilePath = os.path.join(os.getcwd(), "firefox_profile", "linkedin_profile")
+
+class Firefox(Browser):
+    """Firefox browser implementation"""
+    browser_type: BrowserType = BrowserType.FIREFOX
+
+    def create_options(self) -> webdriver.FirefoxOptions:
+        """Create Firefox-specific options"""
+        self.profile.ensure_profile_exists()
+        options = webdriver.FirefoxOptions()
+
+        firefox_arguments = [
+            "--start-maximized", "--no-sandbox", "--disable-dev-shm-usage",
+            "--ignore-certificate-errors", "--disable-extensions", "--disable-gpu",
+            "--disable-background-timer-throttling",
+            "--disable-backgrounding-occluded-windows", "--disable-translate",
+            "--disable-popup-blocking", "--no-first-run", "--no-default-browser-check",
+            "--disable-logging", "--disable-autofill", "--disable-plugins",
+            "--disable-animations", "--disable-cache"
+        ]
+
+        for arg in firefox_arguments:
+            options.add_argument(arg)
+
+        prefs = {
+            "permissions.default.image": 2,
+            "permissions.default.stylesheet": 2,
+        }
+        for key, value in prefs.items():
+            options.set_preference(key, value)
+
+        if self.profile.profile_path:
+            profile = webdriver.FirefoxProfile(self.profile.profile_path)
+            options.profile = profile
+            logger.debug(f"Using Firefox profile directory: {self.profile.profile_path}")
+        else:
+            options.set_preference("browser.privatebrowsing.autostart", True)
+            logger.debug("Using Firefox in private browsing mode")
+
+        return options
+
+    def create_service(self) -> FirefoxService:
+        """Create Firefox-specific service"""
+        return FirefoxService(GeckoDriverManager().install())
+
+    def _create_driver_instance(self, service, options):
+        """Create Firefox WebDriver instance"""
+        return webdriver.Firefox(service=service, options=options)