plexflow 0.0.64__py3-none-any.whl

plexflow/utils/antibot/human_like_requests.py

@@ -0,0 +1,122 @@
+import subprocess
+import time
+import os
+import logging
+import re
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import TimeoutException
+from seleniumbase import SB
+
+class HumanLikeRequestCapture:
+    def __init__(self, url, html, screenshot, cookies):
+        self.url = url
+        self.html = html
+        self.screenshot = screenshot
+        self.cookies = cookies
+
+class HumanLikeRequestSession:
+    def __init__(self, use_xvfb=False):
+        self.use_xvfb = use_xvfb
+        if self.use_xvfb:
+            self._start_xvfb()
+
+    def _start_xvfb(self):
+        self.xvfb_process = subprocess.Popen(['Xvfb', ':99', '-screen', '0', '1920x1080x24'])
+        logging.info("Xvfb started")
+        time.sleep(5)
+        os.environ['DISPLAY'] = ':99'
+
+    def _stop_xvfb(self):
+        if self.xvfb_process:
+            self.xvfb_process.terminate()
+            logging.info("Xvfb terminated")
+
+    def execute_requests(self, urls: iter, take_screenshot: bool = False, wait_condition: str = "element", wait_value: str = "content", wait_until_not: bool = False, max_retries: int = 3) -> iter:
+        with SB(uc=True, maximize=True, test=False, headed=True, incognito=True, chromium_arg="--disable-search-engine-choice-screen") as sb:
+            logging.info("Running test task")
+            for url in urls:
+                cookies = None
+                for attempt in range(max_retries):
+                    logging.info(f"[{attempt}/{max_retries}] Opening URL")
+                    sb.uc_open_with_reconnect(url, 10)
+                    sb.uc_gui_click_cf()
+                    cookies = sb.get_cookies()
+                    logging.info(cookies)
+
+                    # Wait for a specific condition instead of sleeping
+                    try:
+                        if wait_condition == "element":
+                            if wait_until_not:
+                                WebDriverWait(sb.driver, 20).until_not(
+                                    EC.presence_of_element_located((By.ID, wait_value))
+                                )
+                            else:
+                                WebDriverWait(sb.driver, 20).until(
+                                    EC.presence_of_element_located((By.ID, wait_value))
+                                )
+                        elif wait_condition == "regex":
+                            if wait_until_not:
+                                WebDriverWait(sb.driver, 20).until_not(
+                                    lambda driver: re.search(wait_value, driver.page_source)
+                                )
+                            else:
+                                WebDriverWait(sb.driver, 20).until(
+                                    lambda driver: re.search(wait_value, driver.page_source)
+                                )
+                        elif wait_condition == "custom":
+                            result = [None]  # Use a list to store the result
+                            if wait_until_not:
+                                WebDriverWait(sb.driver, 20).until_not(
+                                    lambda driver: (result.__setitem__(0, wait_value(driver)) or result[0])
+                                )
+                            else:
+                                WebDriverWait(sb.driver, 20).until(
+                                    lambda driver: (result.__setitem__(0, wait_value(driver)) or result[0])
+                                )
+
+                            print("Result:", result[0])
+
+                            if result[0] == "retry":
+                                continue
+                    except TimeoutException:
+                        logging.warning("Wait condition not met within the timeout period.")
+                    
+                    break
+            
+                if take_screenshot:
+                    logging.info("Taking screenshot")
+                    screenshot = sb.driver.get_screenshot_as_png()
+                else:
+                    screenshot = None
+
+                html = sb.get_page_source()
+                
+                # Assuming HumanLikeRequestCapture is the response object
+                yield HumanLikeRequestCapture(url=url, html=html, screenshot=screenshot, cookies=cookies)
+
+    def execute_request(self, url: str, take_screenshot: bool = False, wait_condition: str = "element", wait_value: str = "content", wait_until_not: bool = False) -> HumanLikeRequestCapture:
+        return next(self.execute_requests([url], take_screenshot, wait_condition, wait_value, wait_until_not))
+
+    def close(self):
+        if self.use_xvfb:
+            self._stop_xvfb()
+
+def get(url: str, take_screenshot: bool = False, use_xvfb: bool = False, wait_condition: str = "element", wait_value: str = "content", wait_until_not: bool = False) -> HumanLikeRequestCapture:
+    session = HumanLikeRequestSession(use_xvfb=use_xvfb)
+    try:
+        response = session.execute_request(url=url, take_screenshot=take_screenshot, wait_condition=wait_condition, wait_value=wait_value, wait_until_not=wait_until_not)
+        response.use_xvfb = use_xvfb
+        return response
+    finally:
+        session.close()
+
+def get_multiple(urls: iter, take_screenshot: bool = False, use_xvfb: bool = False, wait_condition: str = "element", wait_value: str = "content", wait_until_not: bool = False) -> iter:
+    session = HumanLikeRequestSession(use_xvfb=use_xvfb)
+    try:
+        for response in session.execute_requests(urls=urls, take_screenshot=take_screenshot, wait_condition=wait_condition, wait_value=wait_value, wait_until_not=wait_until_not):
+            response.use_xvfb = use_xvfb
+            yield response
+    finally:
+        session.close()

plexflow/utils/api/context/http.py

@@ -0,0 +1,62 @@
+import requests
+from typing import Optional, Dict
+
+class HttpRequestContext:
+    """
+    A base class for setting up a default request context for headers, params, etc.
+    
+    Args:
+        base_url (str): The base URL for the API.
+        default_headers (dict, optional): The default headers for the API. Defaults to None.
+        default_params (dict, optional): The default parameters for the API. Defaults to None.
+        
+    Attributes:
+        session (requests.Session): The requests Session instance.
+    """
+    
+    def __init__(self, base_url: str, default_headers: Optional[Dict[str, str]] = None, default_params: Optional[Dict[str, str]] = None):
+        self.session = requests.Session()
+        self.session.headers.update(default_headers or {})
+        self.session.params.update(default_params or {})
+        self.base_url = base_url
+        self.default_headers = default_headers
+        self.default_params = default_params
+
+    def get(self, endpoint: str, headers: Optional[Dict[str, str]] = None, params: Optional[Dict[str, str]] = None, **kwargs) -> requests.Response:
+        return self.request('GET', endpoint, headers, params, **kwargs)
+
+    def post(self, endpoint: str, headers: Optional[Dict[str, str]] = None, params: Optional[Dict[str, str]] = None, **kwargs) -> requests.Response:
+        return self.request('POST', endpoint, headers, params, **kwargs)
+
+    def put(self, endpoint: str, headers: Optional[Dict[str, str]] = None, params: Optional[Dict[str, str]] = None, **kwargs) -> requests.Response:
+        return self.request('PUT', endpoint, headers, params, **kwargs)
+
+    def delete(self, endpoint: str, headers: Optional[Dict[str, str]] = None, params: Optional[Dict[str, str]] = None, **kwargs) -> requests.Response:
+        return self.request('DELETE', endpoint, headers, params, **kwargs)
+
+    def request(self, method: str, endpoint: str, headers: Optional[Dict[str, str]] = None, params: Optional[Dict[str, str]] = None, **kwargs) -> requests.Response:
+        """
+        Makes an HTTP request.
+        
+        Args:
+            method (str): The HTTP method.
+            endpoint (str): The endpoint for the HTTP request.
+            headers (dict, optional): The headers for the HTTP request. Defaults to None.
+            params (dict, optional): The parameters for the HTTP request. Defaults to None.
+            **kwargs: Additional arguments passed to requests.Session.request.
+        
+        Returns:
+            The response from the HTTP request.
+        """
+        if headers:
+            self.session.headers.update(headers)
+        if params:
+            self.session.params.update(params)
+        
+        response = self.session.request(method, self.base_url + endpoint, **kwargs)
+        
+        # Reset headers and params to defaults after each request
+        self.session.headers = self.default_headers or {}
+        self.session.params = self.default_params or {}
+        
+        return response

plexflow/utils/api/rest/antibot_restful.py

@@ -0,0 +1,68 @@
+from typing import Optional, Dict
+import requests
+import plexflow.utils.antibot.human_like_requests as human_like_requests
+from urllib.parse import urljoin, urlencode, urlunparse, urlparse
+from plexflow.utils.image.storage import upload_image
+import logging
+
+class AntibotRestful:
+    def __init__(self, base_url: str, use_xvfb: bool = False):
+        self._base_url = base_url
+        self._use_xvfb = use_xvfb
+
+    def _construct_url(self, path: str, query_params: Optional[Dict[str, str]] = None) -> str:
+        # Join the base URL and path
+        url = urljoin(self._base_url, path)
+        
+        # Parse the URL and add query parameters
+        url_parts = list(urlparse(url))
+        if query_params:
+            url_parts[4] = urlencode(query_params)
+        return urlunparse(url_parts)
+
+    def get(self, path: str, headers: Optional[Dict[str, str]] = None, query_params: Optional[Dict[str, str]] = None, **kwargs) -> human_like_requests.HumanLikeRequestCapture:
+        # Construct the full URL
+        url = self._construct_url(path, query_params)
+        
+        # captures = human_like_requests.get_multiple(
+        #     urls=["https://extratorrent.st/search/?new=1&search=twister+2024&s_cat=1", url],
+        #     take_screenshot=True,
+        #     use_xvfb=self._use_xvfb,
+        #     wait_condition=kwargs.get('wait_condition', "regex"),
+        #     wait_value=kwargs.get('wait_value', "magnet:"),
+        #     wait_until_not=kwargs.get('wait_until_not', False)
+        # )
+        
+        # for capture in captures:
+        #     if capture.url == url:
+        #         return capture
+        
+        capture = human_like_requests.get(
+            url=url,
+            take_screenshot=True,
+            use_xvfb=self._use_xvfb,
+            wait_condition=kwargs.get('wait_condition', "regex"),
+            wait_value=kwargs.get('wait_value', "magnet:"),
+            wait_until_not=kwargs.get('wait_until_not', False)
+        )
+        
+        if isinstance(capture.screenshot, bytes):
+            try:
+                image = capture.screenshot
+                image_id = f"{self.url_to_slug(url)}_screenshot"
+                details = upload_image(image, public_id=image_id)
+                logging.info(f"Uploaded screenshot for {image_id}: {details}")
+            except Exception as e:
+                logging.error(f"An error occurred while uploading the screenshot for {image_id}: {e}")
+    
+        return capture
+    
+    def url_to_slug(self, url: str) -> str:
+        # Parse the URL to extract the netloc
+        parsed_url = urlparse(url)
+        netloc = parsed_url.netloc
+        
+        # Replace dots in the netloc with hyphens
+        slug = netloc.replace('.', '-')
+        
+        return slug

plexflow/utils/api/rest/restful.py

@@ -0,0 +1,49 @@
+from typing import Optional, Dict, Any
+import requests
+from plexflow.utils.api.context.http import HttpRequestContext
+
+class Restful:
+    """
+    A class that uses UniversalHttpHook and UniversalPostgresqlHook to create RESTful API interfaces and interact with a PostgreSQL database.
+    
+    Args:
+        http_conn_id (str, optional): The connection ID, used as Airflow connection ID or as the name for the YAML file. Defaults to None.
+        postgres_conn_id (str, optional): The connection ID, used as Airflow connection ID or as the name for the YAML file. Defaults to None.
+        config_folder (str, optional): The folder where the YAML configuration file is located. Defaults to None.
+    """
+    
+    def __init__(self, base_url: str):
+        self._base_url = base_url
+
+    def get(self, url: str, headers: Optional[Dict[str, str]] = None, query_params: Optional[Dict[str, str]] = None, **kwargs) -> requests.Response:
+        """
+        Makes a GET request to the resource.
+        
+        Args:
+            url (str): The full URL for the GET request.
+            headers (dict, optional): The headers for the GET request. Defaults to None.
+            query_params (dict, optional): The query parameters for the GET request. Defaults to None.
+            **kwargs: Additional keyword arguments for the GET request.
+        
+        Returns:
+            The response from the GET request.
+        """
+        context = HttpRequestContext(self._base_url)
+        return context.get(url, headers=headers, params=query_params, **kwargs)
+
+    def post(self, url: str, data: Dict[str, Any], headers: Optional[Dict[str, str]] = None, query_params: Optional[Dict[str, str]] = None, **kwargs) -> requests.Response:
+        """
+        Makes a POST request to the resource.
+        
+        Args:
+            url (str): The full URL for the POST request.
+            data (dict): The data for the POST request.
+            headers (dict, optional): The headers for the POST request. Defaults to None.
+            query_params (dict, optional): The query parameters for the POST request. Defaults to None.
+            **kwargs: Additional keyword arguments for the POST request.
+        
+        Returns:
+            The response from the POST request.
+        """
+        context = HttpRequestContext(self._base_url)
+        return context.post(url, headers=headers, params=query_params, **kwargs)

plexflow/utils/captcha/bypass/decode_audio.py

@@ -0,0 +1,34 @@
+from plexflow.utils.transcribe.speech2text import transcribe_audio
+import os
+from typing import Any, Dict
+
+def get_captcha_code_from_audio(file_path: str, **kwargs: Dict[str, Any]) -> str:
+    """
+    Transcribes an audio file to text, representing a CAPTCHA code.
+
+    This function takes the path of an audio file as input, transcribes it to text using the `transcribe_audio` function,
+    and returns the transcribed text as a CAPTCHA code. The returned CAPTCHA code has no whitespace, is in all caps,
+    and contains no punctuation.
+
+    Args:
+        file_path (str): The path of the audio file to transcribe.
+        **kwargs: Arbitrary keyword arguments for the `transcribe_audio` function.
+
+    Returns:
+        str: The transcribed CAPTCHA code.
+
+    Raises:
+        RuntimeError: If the transcription fails for any reason.
+    """
+    try:
+        # Transcribe the audio file to text
+        text = transcribe_audio(file_path=file_path, **kwargs)
+        
+        # Remove whitespace, convert to uppercase, and remove punctuation
+        captcha_code = ''.join(char for char in text if char.isalnum()).upper()
+
+        return captcha_code
+
+    except Exception as e:
+        error_message = f"Failed to get CAPTCHA code from audio file: {os.path.abspath(file_path)}"
+        raise RuntimeError(error_message) from e

plexflow/utils/download/gz.py

@@ -0,0 +1,26 @@
+import requests
+import gzip
+import io
+
+def download_and_extract_gz(url, output_filename):
+    """Download and extract a .gz file from a URL.
+
+    Parameters:
+    url (str): The URL of the .gz file to download.
+    output_filename (str): The name of the output file.
+
+    Returns:
+    None
+    """
+    # Download the file
+    response = requests.get(url)
+    compressed_file = io.BytesIO(response.content)
+
+    # Decompress the file
+    decompressed_file = gzip.GzipFile(fileobj=compressed_file)
+
+    # Write to a .txt file
+    with open(output_filename, "wb") as outfile:
+        outfile.write(decompressed_file.read())
+
+    print(f"File downloaded and extracted to {output_filename} successfully.")

plexflow/utils/filesystem/search.py

@@ -0,0 +1,129 @@
+import os
+from typing import Generator, Tuple
+
+def search_files(directory: str, extensions: Tuple[str, ...], order_by_size: bool = False, ignore_hidden: bool = True) -> Generator[str, None, None]:
+    """
+    Generator function to search for files in a directory recursively. If extensions are specified, 
+    only files with those extensions are returned. If no extensions are specified, all files are returned.
+    Optionally order the files by size and/or ignore hidden files.
+
+    Parameters:
+    directory (str): The directory in which to start the search.
+    extensions (tuple of str): The file extensions to search for. If empty, all files are returned.
+    order_by_size (bool, optional): Whether to order the files by size. Default is False.
+    ignore_hidden (bool, optional): Whether to ignore hidden files. Default is True.
+
+    Yields:
+    str: The path to a file that matches one of the specified extensions, or any file if no extensions are specified.
+
+    Examples:
+    >>> # Search for Python and text files, ordered by size, including hidden files
+    >>> for file in search_files('/path/to/directory', ('.txt', '.py'), order_by_size=True, ignore_hidden=False):
+    ...     print(file)
+
+    >>> # Search for JPEG and PNG images, not ordered by size, ignoring hidden files
+    >>> for file in search_files('/path/to/directory', ('.jpg', '.png')):
+    ...     print(file)
+
+    >>> # Search for Markdown files, ordered by size, ignoring hidden files
+    >>> for file in search_files('/path/to/directory', ('.md',), order_by_size=True):
+    ...     print(file)
+
+    >>> # Search for all files, not ordered by size, ignoring hidden files
+    >>> for file in search_files('/path/to/directory', (), order_by_size=False, ignore_hidden=True):
+    ...     print(file)
+    """
+
+    # Gather all files first if ordering by size
+    if order_by_size:
+        files = []
+        for dirpath, dirnames, filenames in os.walk(directory):
+            if ignore_hidden:
+                filenames = [f for f in filenames if not f[0] == '.']
+                dirnames[:] = [d for d in dirnames if not d[0] == '.']
+            for filename in filenames:
+                if not extensions or filename.endswith(extensions):
+                    filepath = os.path.join(dirpath, filename)
+                    files.append((os.path.getsize(filepath), filepath))
+        files.sort()  # Files are now sorted by size
+        for _, filepath in files:
+            yield filepath
+    else:
+        # Original behavior, yield files as they are found
+        for dirpath, dirnames, filenames in os.walk(directory):
+            if ignore_hidden:
+                filenames = [f for f in filenames if not f[0] == '.']
+                dirnames[:] = [d for d in dirnames if not d[0] == '.']
+            for filename in filenames:
+                if not extensions or filename.endswith(extensions):
+                    yield os.path.join(dirpath, filename)
+
+
+def find_movie_files(directory: str, extensions: Tuple[str, ...] = ('.mp4', '.mkv', '.avi', '.mov', '.flv'), order_by_size: bool = False, ignore_hidden: bool = True) -> Generator[str, None, None]:
+    """
+    Generator function to search for movie files in a directory recursively. 
+    Movie files are considered to have the extensions: '.mp4', '.mkv', '.avi', '.mov', '.flv', unless specified otherwise.
+    Optionally order the files by size and/or ignore hidden files.
+
+    Parameters:
+    directory (str): The directory in which to start the search.
+    extensions (tuple of str, optional): The file extensions to search for. Default is ('.mp4', '.mkv', '.avi', '.mov', '.flv').
+    order_by_size (bool, optional): Whether to order the files by size. Default is False.
+    ignore_hidden (bool, optional): Whether to ignore hidden files. Default is True.
+
+    Yields:
+    str: The path to a movie file.
+
+    Examples:
+    >>> # Search for movie files, ordered by size, including hidden files
+    >>> for file in find_movie_files('/path/to/directory', order_by_size=True, ignore_hidden=False):
+    ...     print(file)
+
+    >>> # Search for movie files, not ordered by size, ignoring hidden files
+    >>> for file in find_movie_files('/path/to/directory'):
+    ...     print(file)
+
+    >>> # Search for movie files, ordered by size, ignoring hidden files
+    >>> for file in find_movie_files('/path/to/directory', order_by_size=True):
+    ...     print(file)
+
+    >>> # Search for custom file types
+    >>> for file in find_movie_files('/path/to/directory', extensions=('.wmv', '.mpg')):
+    ...     print(file)
+    """
+    return search_files(directory, extensions, order_by_size, ignore_hidden)
+
+
+def find_subtitle_files(directory: str, extensions: Tuple[str, ...] = ('.srt', '.sub', '.sbv', '.vtt', '.ass'), order_by_size: bool = False, ignore_hidden: bool = True) -> Generator[str, None, None]:
+    """
+    Generator function to search for subtitle files in a directory recursively. 
+    Subtitle files are considered to have the extensions: '.srt', '.sub', '.sbv', '.vtt', '.ass', unless specified otherwise.
+    Optionally order the files by size and/or ignore hidden files.
+
+    Parameters:
+    directory (str): The directory in which to start the search.
+    extensions (tuple of str, optional): The file extensions to search for. Default is ('.srt', '.sub', '.sbv', '.vtt', '.ass').
+    order_by_size (bool, optional): Whether to order the files by size. Default is False.
+    ignore_hidden (bool, optional): Whether to ignore hidden files. Default is True.
+
+    Yields:
+    str: The path to a subtitle file.
+
+    Examples:
+    >>> # Search for subtitle files, ordered by size, including hidden files
+    >>> for file in find_subtitle_files('/path/to/directory', order_by_size=True, ignore_hidden=False):
+    ...     print(file)
+
+    >>> # Search for subtitle files, not ordered by size, ignoring hidden files
+    >>> for file in find_subtitle_files('/path/to/directory'):
+    ...     print(file)
+
+    >>> # Search for subtitle files, ordered by size, ignoring hidden files
+    >>> for file in find_subtitle_files('/path/to/directory', order_by_size=True):
+    ...     print(file)
+
+    >>> # Search for custom file types
+    >>> for file in find_subtitle_files('/path/to/directory', extensions=('.smi', '.ssa')):
+    ...     print(file)
+    """
+    return search_files(directory, extensions, order_by_size, ignore_hidden)

plexflow/utils/gmail/mails.py

@@ -0,0 +1,116 @@
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+import pickle
+import os
+from typing import Any
+
+class GmailAuthenticatedContext:
+    """
+    A context manager for managing the authentication and retrieval of Gmail messages.
+
+    Args:
+        token_path (str): The path to the token file for storing the authentication token. Default is 'config/gmail_token.pickle'.
+        creds_path (str): The path to the credentials file for Gmail API. Default is 'config/gmail_credentials.json'.
+        scopes (tuple): The OAuth 2.0 scopes for the Gmail API. Default is ('https://www.googleapis.com/auth/gmail.readonly',).
+
+    Methods:
+        __enter__(): Enters the context and authenticates the Gmail API client.
+        __exit__(exc_type, exc_val, exc_tb): Exits the context.
+        get_messages_since_history_id(history_id, label_id): Retrieves the messages added since the specified history ID for a given label.
+        authenticate(): Authenticates the Gmail API client.
+
+    """
+
+    def __init__(self, token_path='config/gmail_token.pickle', creds_path='config/gmail_credentials.json', scopes=('https://www.googleapis.com/auth/gmail.readonly',)):
+        self.token_path = token_path
+        self.creds_path = creds_path
+        self.scopes = scopes
+
+    def __enter__(self):
+        self.creds = self.authenticate()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def get_label_id(self, label_name: str) -> str:
+        """
+        Retrieves the label ID for a given label name.
+
+        Args:
+            label_name (str): The name of the label.
+
+        Returns:
+            str: The ID of the label if found, None otherwise.
+        """
+        try:
+            service = build('gmail', 'v1', credentials=self.creds)
+            results = service.users().labels().list(userId='me').execute()
+            labels = results.get('labels', [])
+            for label in labels:
+                if label['name'] == label_name:
+                    return label['id']
+        except Exception as e:
+            raise RuntimeError(f"Failed to retrieve label ID for '{label_name}'") from e
+        
+        return None
+    def get_messages_since_history_id(self, history_id: int, label_name: str) -> list:
+        """
+        Retrieves the messages added since the specified history ID for a given label name.
+
+        Args:
+            history_id (int): The history ID to start retrieving changes from.
+            label_name (str): The name of the label to filter the changes.
+
+        Returns:
+            list: A list of message objects that were added since the specified history ID.
+        """
+        label_id = self.get_label_id(label_name)
+        if not label_id:
+            raise RuntimeError(f"Failed to retrieve label ID for '{label_name}'")
+
+        # Use history.list to get the change details
+        service = build('gmail', 'v1', credentials=self.creds)
+        try:
+            results = service.users().history().list(userId='me', startHistoryId=history_id).execute()
+            changes = results.get('history', [])
+
+            # Get the body of the messages added
+            messages = []
+            for change in changes:
+                messages_added = change.get('messagesAdded', [])
+                for message_added in messages_added:
+                    message_id = message_added['message']['id']
+                    message = service.users().messages().get(userId='me', id=message_id).execute()
+                    messages.append(message)
+
+            return messages
+        except Exception as e:
+            raise RuntimeError("Failed to retrieve messages") from e
+
+    def authenticate(self) -> Any:
+        """
+        Authenticates the user and returns the credentials.
+
+        Returns:
+            The credentials object after authentication.
+        """
+        creds: Any = None
+
+        if os.path.exists(self.token_path):
+            with open(self.token_path, 'rb') as token:
+                creds = pickle.load(token)
+
+        if not creds or not creds.valid:
+            if creds and creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+            else:
+                flow = InstalledAppFlow.from_client_secrets_file(
+                    self.creds_path, self.scopes)
+                creds = flow.run_local_server(port=0)
+
+            with open(self.token_path, 'wb') as token:
+                pickle.dump(creds, token)
+
+        return creds