abstract-webtools 0.1.4.40__py3-none-any.whl → 0.1.4.42__py3-none-any.whl

abstract_webtools/abstract_webtools.py

@@ -71,14 +71,13 @@ import requests
 import os
 # Google Chrome Driver
 from selenium import webdriver
-import yt_dlp
 import ssl
 import re
+import yt_dlp
 import threading
 import requests
-import time
 from requests.adapters import HTTPAdapter
-from typing import Optional, List
+from typing import Optional, List,Union
 from requests.packages.urllib3.poolmanager import PoolManager
 from requests.packages.urllib3.util import ssl_
 from urllib.parse import urlparse
@@ -220,6 +219,7 @@ class DynamicRateLimiterManagerSingleton:
             DynamicRateLimiterManagerSingleton._instance = DynamicRateLimiterManager(service_name=service_name, low_limit=low_limit, high_limit=limit_epoch, limit_epoch=60,starting_tokens=starting_tokens,epoch_cycle_adjustment=epoch_cycle_adjustment)
         return DynamicRateLimiterManagerSingleton._instance
 
+
 class CipherManager:
     @staticmethod
     def  get_default_ciphers()-> list:
@@ -259,124 +259,15 @@ class CipherManagerSingleton:
             CipherManagerSingleton._instance = CipherManager(cipher_list=cipher_list)
         return CipherManagerSingleton._instance
 class SSLManager:
-    @staticmethod
-    def get_default_certification():
-        return ssl.CERT_REQUIRED
-
-    @staticmethod
-    def get_default_tls_options():
-        return ["OP_NO_TLSv1", "OP_NO_TLSv1_1", "OP_NO_COMPRESSION"]
-
-    @staticmethod
-    def get_all_tls_options() -> int:
-        """
-        Returns the SSL options to be used when creating the SSL context.
-            [
-         ssl.OP_SINGLE_ECDH_USE,
-         ssl.OP_SINGLE_DH_USE,
-         ssl.OP_NO_TLSv1_3,
-         ssl.OP_NO_TLSv1_2,
-         ssl.OP_NO_TLSv1_1,
-         ssl.OP_NO_TLSv1,
-         ssl.OP_NO_TICKET,
-         ssl.OP_NO_RENEGOTIATION,
-         ssl.OP_NO_QUERY_MTU,
-         ssl.OP_NO_COMPRESSION,
-         ssl.OP_CIPHER_SERVER_PREFERENCE,
-         ssl.OP_ALLOW_NO_DHE_KEX,
-         ssl.OP_ALL
-         ]
-         The `ssl` module in the Python standard library provides several constants that you can use to set various SSL options. Here are the available options as of Python 3.9:
-
-        1. `ssl.OP_ALL`:
-           - Enables a collection of various bug workaround options.
-
-        2. `ssl.OP_ALLOW_NO_DHE_KEX`:
-           - Allow a non-(EC)DHE handshake on a server socket if no suitable security level can be reached.
-
-        3. `ssl.OP_CIPHER_SERVER_PREFERENCE`:
-           - Uses the server's cipher ordering preference rather than the client's.
-
-        4. `ssl.OP_NO_COMPRESSION`:
-           - Prevents using SSL/TLS compression to avoid CRIME attacks.
-
-        5. `ssl.OP_NO_QUERY_MTU`:
-           - Disables automatic querying of kernel for MTU.
-
-        6. `ssl.OP_NO_RENEGOTIATION`:
-           - Disallows all renegotiation.
+    def __init__(self, ciphers=None, ssl_options=None, certification=None):
+        self.ciphers = ciphers or "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:AES256-SHA:AES128-SHA"
+        self.ssl_options = ssl_options or ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1 | ssl.OP_NO_COMPRESSION
+        self.certification = certification or ssl.CERT_REQUIRED
+        self.ssl_context = self.get_context()
 
-        7. `ssl.OP_NO_TICKET`:
-           - Disables use of RFC 5077 session tickets.
+    def get_context(self):
+        return ssl_.create_urllib3_context(ciphers=self.ciphers, cert_reqs=self.certification, options=self.ssl_options)
 
-        8. `ssl.OP_NO_TLSv1`:
-           - Prevents the use of TLSv1.
-
-        9. `ssl.OP_NO_TLSv1_1`:
-           - Prevents the use of TLSv1.1.
-
-        10. `ssl.OP_NO_TLSv1_2`:
-           - Prevents the use of TLSv1.2.
-
-        11. `ssl.OP_NO_TLSv1_3`:
-           - Prevents the use of TLSv1.3.
-
-        12. `ssl.OP_SINGLE_DH_USE`:
-           - Always create a new key when using temporary/ephemeral DH parameters. This option provides forward secrecy.
-
-        13. `ssl.OP_SINGLE_ECDH_USE`:
-           - Always create a new key when using temporary/ephemeral ECDH parameters. This option provides forward secrecy.
-
-        These constants can be combined using the bitwise OR (`|`) operator to set multiple options. For example, to prevent the use of TLSv1 and TLSv1.1, you would use:
-        Please note that the availability of some options might vary depending on the version of OpenSSL that Python's `ssl` module is linked against and the version of Python itself. You can always check the Python documentation specific to your version to get the most accurate and updated list.
-
-        Returns:
-            int: The SSL options.
-
-        """
-        return [
-            "OP_SINGLE_ECDH_USE",
-            "OP_SINGLE_DH_USE",
-            "OP_NO_TLSv1_3",
-            "OP_NO_TLSv1_2",
-            "OP_NO_TLSv1_1",
-            "OP_NO_TLSv1",
-            "OP_NO_TICKET",
-            "OP_NO_RENEGOTIATION",
-            "OP_NO_QUERY_MTU",
-            "OP_NO_COMPRESSION",
-            "OP_CIPHER_SERVER_PREFERENCE",
-            "OP_ALLOW_NO_DHE_KEX",
-            "OP_ALL"
-            ]
-
-    @staticmethod
-    def get_context(ciphers=None, options=None, cert_reqs=None):
-        
-        return ssl_.create_urllib3_context(ciphers=ciphers, cert_reqs=cert_reqs, options=options)
-
-    def __init__(self, ciphers=None, ssl_options_list=None, certification=None):
-        self.ssl_options_list = ssl_options_list
-        self.create_list()
-        self.ssl_options_values = self.get_options_values()
-        self.ssl_options = self.combine_ssl_options()
-        self.certification = certification or self.get_default_certification()
-        self.cipher_manager = CipherManagerSingleton().get_instance(cipher_list=ciphers)
-        self.ssl_context = self.get_context(ciphers=self.cipher_manager.ciphers_string, options=self.ssl_options, cert_reqs=self.certification)
-    def create_list(self):
-        if self.ssl_options_list == None:
-            self.ssl_options_list= []
-        elif isinstance(self.ssl_options_list, str):
-            self.ssl_options_list=self.ssl_options_list.split(',')
-        if isinstance(self.ssl_options_list, str):
-            self.ssl_options_list=[self.ssl_options_list]
-    def get_options_values(self):
-        return [getattr(ssl, option_name) for option_name in self.ssl_options_list]
-    def combine_ssl_options(self):
-        combined_options = 0
-        for option in self.ssl_options_values:
-            combined_options |= option
-        return combined_options
 class SSLManagerSingleton:
     _instance = None
     @staticmethod
@@ -387,60 +278,49 @@ class SSLManagerSingleton:
             SSLManagerSingleton._instance = SSLManager(ciphers=ciphers, ssl_options_list=ssl_options_list, certification=certification)
         return SSLManagerSingleton._instance
 class TLSAdapter(HTTPAdapter):
-    def __init__(self, ciphers: Optional[List[str]] = None, certification: Optional[str] = None, ssl_options: Optional[List[str]] = None):
-        super().__init__()
-        self.ciphers = ciphers
-        self.certification = certification
-        self.ssl_options = ssl_options
-        
-        self.cipher_manager = CipherManagerSingleton.get_instance(cipher_list=self.ciphers)
-        self.ssl_manager = SSLManagerSingleton.get_instance(
-            ciphers=self.cipher_manager.ciphers_string, 
-            ssl_options_list=ssl_options, 
-            certification=certification
-        )
+    def __init__(self, ssl_manager=None,ciphers=None, certification: Optional[str] = None, ssl_options: Optional[List[str]] = None):
+        if ssl_manager == None:
+            ssl_manager = SSLManager(ciphers=ciphers, ssl_options=ssl_options, certification=certification)
+        self.ssl_manager = ssl_manager
+        self.ciphers = ssl_manager.ciphers
+        self.certification = ssl_manager.certification
+        self.ssl_options = ssl_manager.ssl_options
         self.ssl_context = self.ssl_manager.ssl_context
+        super().__init__()
 
     def init_poolmanager(self, *args, **kwargs):
+        kwargs['ssl_context'] = self.ssl_context
         return super().init_poolmanager(*args, **kwargs)
-
-
 class TLSAdapterSingleton:
-    _instance = None
+    _instance: Optional[TLSAdapter] = None
+    
     @staticmethod
-    def get_instance(ciphers=None, certification=None, ssl_options=None):
-        if TLSAdapterSingleton._instance is None:
-            TLSAdapterSingleton._instance = TLSAdapter(ciphers=ciphers, certification=certification, ssl_options=ssl_options)
-        elif TLSAdapterSingleton._instance.ciphers != ciphers or SSLManagerSingleton._instance.certification !=certification or SSLManagerSingleton._instance.ssl_options_list !=ssl_options:
+    def get_instance(ciphers: Optional[List[str]] = None, certification: Optional[str] = None, ssl_options: Optional[List[str]] = None) -> TLSAdapter:
+        if (not TLSAdapterSingleton._instance) or (
+            TLSAdapterSingleton._instance.ciphers != ciphers or 
+            TLSAdapterSingleton._instance.certification != certification or 
+            TLSAdapterSingleton._instance.ssl_options != ssl_options
+        ):
             TLSAdapterSingleton._instance = TLSAdapter(ciphers=ciphers, certification=certification, ssl_options=ssl_options)
         return TLSAdapterSingleton._instance
 class UserAgentManager:
+    def __init__(self, user_agent=None):
+        if user_agent == None:
+            user_agent = self.desktop_user_agents()[0]
+        self.user_agent = user_agent
+        self.user_agent=self.get_user_agent(self.user_agent)
     @staticmethod
-         
     def desktop_user_agents() -> list:
-            """
-            Returns a list of popular desktop user-agent strings for various browsers.
-
-            Returns:
-                list: A list of desktop user-agent strings.
-            """
-            return ['Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36','Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:87.0) Gecko/20100101 Firefox/87.0','Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1 Safari/605.1.15','Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36 Edg/91.0.864.59','Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko','Opera/9.80 (Windows NT 6.0) Presto/2.12.388 Version/12.14']
-
+        return ['Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36','Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:87.0) Gecko/20100101 Firefox/87.0','Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1 Safari/605.1.15','Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36 Edg/91.0.864.59','Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko','Opera/9.80 (Windows NT 6.0) Presto/2.12.388 Version/12.14']
     @staticmethod
-    def get_user_agent(user_agent:str=desktop_user_agents()[0]) -> dict:
-            """
-            Returns the user-agent header dictionary with the specified user-agent.
-
-            Args:
-                user_agent (str, optional): The user-agent string to be used. Defaults to the first user-agent in the list.
-
-            Returns:
-                dict: A dictionary containing the 'user-agent' header.
-            """
-            return {"user-agent": user_agent}
-    def __init__(self,user_agent=desktop_user_agents()[0]):
-        self.user_agent = user_agent
-        self.get_user_agent(user_agent=user_agent)
+    def big_user_agent_list(n=0):
+        from .big_user_agent_list import big_user_agent_list
+        return big_user_agent_list[n]
+    @staticmethod
+    def get_user_agent(user_agent: str = desktop_user_agents()[0]) -> dict:
+        if isinstance(user_agent,dict):
+            return user_agent
+        return {"user-agent": user_agent}
 class UserAgentManagerSingleton:
     _instance = None
     @staticmethod
@@ -450,215 +330,20 @@ class UserAgentManagerSingleton:
         elif UserAgentManagerSingleton._instance.user_agent != user_agent:
             UserAgentManagerSingleton._instance = UserAgentManager(user_agent=user_agent)
         return UserAgentManagerSingleton._instance
-def safe_json_loads(data):
-    try:
-        return json.loads(data)
-    except json.JSONDecodeError:
-        return None
-def convert_to_json(obj):
-    if isinstance(obj, dict):
-        return obj
-    if isinstance(obj, str):
-        return safe_json_loads(obj)
-    return None
-class SafeRequest:
-        def __init__(self,
-                     url_manager,
-                     session=None,
-                     headers=None,
-                     cookies=None,
-                     adapter=None,
-                     protocol=None,
-                     proxies=None,
-                     auth=None,
-                     stream=False,
-                     last_request_time=None,
-                     max_retries=None,
-                     request_wait_limit=None):
-            self.url_manager=url_manager
-            self.session=session or requests.Session()
-            self.headers = headers or {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36'}
-            self.cookies=cookies or "cb4c883efc59d0e990caf7508902591f4569e7bf-1617321078-0-150"
-            self.adapter=adapter or TLSAdapterSingleton().get_instance()
-            self.protocol=protocol or 'https://'
-            self.proxies=None or {}
-            self.auth=auth
-            self.stream=stream if isinstance(stream,bool) else False
-            self.last_request_time=last_request_time
-            self.max_retries = max_retries or 3
-            self.request_wait_limit = request_wait_limit or 1.5
-            self.session = self.initialize_session()
-            self.make_request()
-            self.source_code = None
-            self.source_code_bytes=None
-            self.source_code_json = {}
-            self.react_source_code=[]
-            self.get_response()
-        def initialize_session(self):
-            s = self.session
-            s.proxies=self.proxies
-            s.auth=self.auth
-            s.cookies["cf_clearance"] = self.cookies
-            s.headers.update(self.headers)
-            # Add any other headers or cookie settings here
-            s.mount(self.protocol, self.adapter)
-            return s
-        def get_response(self):
-            if self.request:
-                self.source_code = self.request.text
-                self.source_code_bytes=self.request.content
-                self.source_code_json = {}
-                if self.request.headers.get('content-type') == 'application/json':
-                    data = convert_to_json(self.source_code)
-                    if data:
-                        self.source_code_json=data.get("response", data)
-                self.get_react_source_code()
-        def get_react_source_code(self) -> list:
-            """
-            Fetches the source code of the specified URL and extracts JavaScript and JSX source code (React components).
-
-            Args:
-                url (str): The URL to fetch the source code from.
-
-            Returns:
-                list: A list of strings containing JavaScript and JSX source code found in <script> tags.
-            """
-            if  self.url_manager.correct_url is None:
-                return []
-            soup = BeautifulSoup(self.source_code_bytes,"html.parser")
-            script_tags = soup.find_all('script', type=lambda t: t and ('javascript' in t or 'jsx' in t))
-            for script_tag in script_tags:
-                self.react_source_code.append(script_tag.string)
-
-
-        def get_status(url:str=None) -> int:
-            """
-            Gets the HTTP status code of the given URL.
-
-            Args:
-                url (str): The URL to check the status of.
-
-            Returns:
-                int: The HTTP status code of the URL, or None if the request fails.
-            """
-            # Get the status code of the URL
-            return try_request(url=url).status_code
-        def wait_between_requests(self):
-            """
-            Wait between requests based on the request_wait_limit.
-            """
-            if self.last_request_time:
-                sleep_time = self.request_wait_limit - (get_time_stamp() - self.last_request_time)
-                if sleep_time > 0:
-                    logging.info(f"Sleeping for {sleep_time:.2f} seconds.")
-                    get_sleep(sleep_time)
-
-        def make_request(self):
-            """
-            Make a request and handle potential errors.
-            """
-            # Update the instance attributes if they are passed
-
-            self.wait_between_requests()
-            for _ in range(self.max_retries):
-                try:
-                    self.try_request()  # 10 seconds timeout
-                    if self.request:
-                        if self.request.status_code == 200:
-                            self.last_request_time = get_time_stamp()
-                            return self.request
-                        elif self.request.status_code == 429:
-                            logging.warning(f"Rate limited by {self.url_manager.correct_url}. Retrying...")
-                            get_sleep(5)  # adjust this based on the server's rate limit reset time
-                except requests.Timeout as e:
-                    logging.error(f"Request to {cleaned_url} timed out: {e}")
-                except requests.ConnectionError:
-                    logging.error(f"Connection error for URL {self.url_manager.correct_url}.")
-                except requests.Timeout:
-                    logging.error(f"Request timeout for URL {self.url_manager.correct_url}.")
-                except requests.RequestException as e:
-                    logging.error(f"Request exception for URL {self.url_manager.correct_url}: {e}")
-
-            logging.error(f"Failed to retrieve content from {self.url_manager.correct_url} after {self.max_retries} retries.")
-            return None
-        def try_request(self,timeout=10) -> (requests.Response or None):
-            """
-            Tries to make an HTTP request to the given URL using the provided session.
-
-            Args:
-                url (str): The URL to make the request to.
-                session (type(requests.Session), optional): The requests session to use for making HTTP requests.
-                    Defaults to requests.
-
-            Returns:
-                requests.Response or None: The response object if the request is successful, or None if the request fails.
-            """
-            try:
-                self.request = self.session.get(url=self.url_manager.url, timeout=10)
-            except requests.exceptions.RequestException as e:
-                print(e)
-            return False
-        def get_limited_request(self,request_url,service_name="default"):
-            manager = DynamicRateLimiterManagerSingleton.get_instance()  # Get the singleton instance
-            unwanted_response=True
-            # Check with the rate limiter if we can make a request
-            while True:
-                if not manager.request(service_name):
-                    print("Rate limit reached for coin_gecko. Waiting for the next epoch...")
-                    sleep_count_down(manager.services[service_name].get_sleep()["current_sleep"])  # Wait for the limit_epoch duration
-                # Make the actual request
-                response = try_request(request_url=request_url)
-                
-                # If you get a rate-limit error (usually 429 status code but can vary), adjust the rate limiter
-                if response.status_code ==429:
-                    print(response.json())
-                    manager.services[service_name].request_tracker(False)
-                    print("Rate limited by coin_gecko. Adjusted limit. Retrying...")
-                    if len(manager.services[service_name].calculate_tokens()["succesful"])<2:
-                        sleep_count_down(manager.services[service_name].limit_epoch)  # Wait for the limit_epoch duration
-                    else:
-                        manager.services[service_name].current_limit-=1
-                        sleep_count_down(manager.services[service_name].limit_epoch/len(manager.services[service_name].calculate_tokens()["succesful"]))  # Wait for the limit_epoch duration
-                # Return the data if the request was successful
-                if response.status_code == 200:
-                    manager.services[service_name].request_tracker(True)
-                    return response.json()
-                elif response.status_code not in [200,429]:
-                    print(f"Unexpected response: {response.status_code}. Message: {response.text}")
-                    return None
-        @property
-        def url(self):
-            return self.url_manager.url
-
-        @url.setter
-        def url(self, new_url):
-            self._url_manager.url = new_url
-class SafeRequestSingleton:
-    _instance = None
-    @staticmethod
-    def get_instance(url=None,headers:dict=None,max_retries=3,last_request_time=None,request_wait_limit=1.5):
-        if SafeRequestSingleton._instance is None:
-            SafeRequestSingleton._instance = SafeRequest(url,url_manager=URLManagerSingleton,headers=headers,max_retries=max_retries,last_request_time=last_request_time,request_wait_limit=request_wait_limit)
-        elif SafeRequestSingleton._instance.url != url or SafeRequestSingleton._instance.headers != headers or SafeRequestSingleton._instance.max_retries != max_retries or SafeRequestSingleton._instance.request_wait_limit != request_wait_limit:
-            SafeRequestSingleton._instance = SafeRequest(url,url_manager=URLManagerSingleton,headers=headers,max_retries=max_retries,last_request_time=last_request_time,request_wait_limit=request_wait_limit)
-        return SafeRequestSingleton._instance
-## ## 
-# Usage
-## safe_requester = SafeRequest()
-## 
-## url = "example.com"  # replace with your URL
-#### if safe_requester.is_valid_url(url):
-##     response = safe_requester.make_request(url)
-##     if response:
-##         print(response.text)
-## else:
-##     logging.error(f"Invalid URL: {url}")
-# Usage 2
-##    safe_requester = SafeRequest()
-##    source_code = safe_requester.get_source_code('https://www.example.com')
-##    if source_code:
-##        print(source_code)
-## ##
+class NetworkManager:
+    def __init__(self, user_agent_manager=None,ssl_manager=None, tls_adapter=None,user_agent=None,proxies=None,auth=None,cookies=None,ciphers=None, certification: Optional[str] = None, ssl_options: Optional[List[str]] = None):
+        if ssl_manager == None:
+            ssl_manager = SSLManager(ciphers=ciphers, ssl_options=ssl_options, certification=certification)
+        self.ssl_manager=ssl_manager
+        if tls_adapter == None:
+            tls_adapter=TLSAdapter(ssl_manager=ssl_manager,ciphers=ciphers, certification=certification, ssl_options=ssl_options)
+        self.tls_adapter=tls_adapter
+        self.ciphers=tls_adapter.ciphers
+        self.certification=tls_adapter.certification
+        self.ssl_options=tls_adapter.ssl_options
+        self.proxies=None or {}
+        self.auth=auth
+        self.cookies=cookies or "cb4c883efc59d0e990caf7508902591f4569e7bf-1617321078-0-150"
 class MySocketClient:
     def __init__(self, ip_address=None, port=None,domain_name=None):
         self.sock
@@ -705,161 +390,21 @@ class MySocketClient():
         elif MySocketClientSingleton._instance.ip_address != ip_address or MySocketClientSingleton._instance.port != port or URLManagerSingleton._instance.domain_name != domain_name:
             MySocketClientSingleton._instance = MySocketClient(ip_address=ip_address,port=port,domain_name=domain_name)
         return MySocketClient
-class VideoDownloader:
-    def __init__(self, url,title=None,download_directory=os.getcwd(),user_agent=None,video_extention='mp4',download_video=True,get_info=False,auto_file_gen=True,standalone_download=False):
-        self.url=url
-        self.monitoring = True
-        self.pause_event = threading.Event()
-        self.get_download = download_video
-        self.get_info = get_info
-        self.user_agent=user_agent
-        self.title = title
-        self.auto_file_gen=auto_file_gen
-        self.standalone_download=standalone_download
-        self.video_extention=video_extention
-        self.download_directory=download_directory
-        self.video_extention=video_extention
-        self.header = {}#UserAgentManagerSingleton().get_instance(user_agent=user_agent)
-        self.base_name = os.path.basename(self.url)
-        self.file_name,self.ext = os.path.splitext(self.base_name)
-        self.video_urls = [self.url]
-        self.fetch_video_urls()
-        self.info={}
-        self.starttime = None
-        self.downloaded = 0
-        self.video_urls = url if isinstance(url,list) else [url]
-        self.send_to_dl()
-        
-
-    def get_request(self,url):
-        self.request_manager = SafeRequestSingleton.get_instance(url=url)
-        return self.request_manager
-    def send_to_dl(self):
-        if self.standalone_download:
-            self.standalone_downloader()
-        else:
-            self.start()
-    def get_headers(self,url):
-        # Send an HTTP GET request to the URL
-        response = requests.get(url)
-        # Check if the request was successful (status code 200)
-        if response.status_code == 200:
-            # Access and print the response headers
-            return response.headers
-        else:
-            print(f"Failed to retrieve the web page. Status code: {response.status_code}")
-    def progress_callback(self, stream, chunk, bytes_remaining):
-        total_size = stream.filesize
-        self.downloaded = total_size - bytes_remaining
-    def get_directory_path(directory,name,video_extention):
-        file_path=os.path.join(directory,name+'.'+video_extention)
-        i=0
-        while os.path.exists(file_path) == True:
-            file_path=os.path.join(directory,name+f'_{i}'+'.'+video_extention)
-            i+=1
-        return file_path
-    def fetch_video_urls(self):
-        driver = webdriver.Chrome()
-        driver.get(self.url)
-        self.page_source = driver.page_source
-        for each in self.page_source.split('<source ')[1:]:
-            # NOTE: Make sure to import the `eatAll` function and use it here.
-            self.video_urls.append(eatInner(each.split('.{self.video_extention}'.replace('..','.'))[0].split('http')[-1],['h','t','t','p','s',':','//','/','s','=',' ','\n','\t',''])+'.mp4')
-    def download(self):
-        for video_url in self.video_urls:
-            ydl_opts = {
-              'external_downloader': 'ffmpeg',
-              'external_downloader_args': "-ss 00:01:00.00 -to 00:02:00.00",
-              'format': 'best',
-              'outtmpl': f'{self.download_directory} %(title)s-%(id)s.%(ext)s',
-              'noprogress': True
-            }
-            self.output_video = ydl_opts['outtmpl']
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                if self.get_download:
-                    self.info = ydl.extract_info(video_url, download=self.get_download).noprogress
-                else:
-                    self.info = ydl.extract_info(video_url, download=self.get_download)
-                self.starttime = time.time()
-                if self.auto_file_gen:
-                    file_path = ydl.prepare_filename(self.info)
-                    if self.get_info == True:
-                        self.info['file_path']=file_path
-                    
-                if self.get_info == True:
-                    self.monitoring = False
-                    self.pause_event.set()
-                    return self.info
-        self.monitoring = False
-        self.pause_event.set()
-    def monitor(self):
-        name =  self.title or False
-        while self.monitoring:
-            print("Monitoring...")
-            self.pause_event.wait(60)  # check every minute
-            if self.starttime:
-                elapsed_time = time.time() - self.starttime
-                if self.downloaded != 0 and elapsed_time !=0:
-                    percent = self.downloaded / (self.downloaded + elapsed_time)
-                else:
-                    percent = 0
-                if elapsed_time !=0:
-                    try:
-                        # operations that can cause ZeroDivisionError
-                        percent = self.downloaded / (self.downloaded + elapsed_time)
-                        downloaded_minutes = elapsed_time / 60
-                        estimated_download_time = downloaded_minutes / percent - downloaded_minutes
-                    except ZeroDivisionError:
-                        print("Caught a division by zero!")
-                        continue
-
-                if downloaded_minutes != 0 and (percent - downloaded_minutes) !=0:
-                    estimated_download_time = downloaded_minutes / percent - downloaded_minutes
-                    print(estimated_download_time)
-                if estimated_download_time >= 1.5:
-                    print("Seems like YouTube is limiting our download speed, restarting the download to mitigate the problem..")
-                    # TODO: Find a way to stop the current download and restart. This may not work efficiently since pytube doesn't expose a cancel download method.
-                    self.start()  # Restart the download process
-    def standalone_downloader(self):
-        name = self.title or False
-        for video_url in self.video_urls:
-                self.request_manager
-                self.info=True
-                self.download_video=False
-                headers = self.get_headers(video_url)
-                for v in soup.select("video source[src]"):
-                    print("Downloading {}".format(v["src"]))
-                    if not name_chosen:
-                        name = v["src"].split("/")[-1].strip()
-                    file_path = get_directory_path(directory,name,video_extention)
-                    print(f"saving to {file_path}")
-                    with open(get_directory_path(directory,name,video_extention), "wb") as f_out:
-                        f_out.write(requests.get(v["src"].strip(), headers=headers).content)
-      
-    def start(self):
-        self.download_thread = threading.Thread(target=self.download)
-        self.download_thread.daemon = True
-        self.monitor_thread = threading.Thread(target=self.monitor)
-        self.download_thread.start()
-        self.monitor_thread.start()
-        self.download_thread.join()
-        self.monitor_thread.join()
-    def stop(self):
-        self.monitoring = False
-
-
-
-class VideoDownloaderSingleton():
-    _instance = None
-    @staticmethod
-    def get_instance(url_manager,request_manager,title=None,video_extention='mp4',download_directory=os.getcwd(),user_agent=None,download=True,get_info=False):
-        if VideoDownloaderSingleton._instance is None:
-            VideoDownloaderSingleton._instance = VideoDownloader(url=url,title=title,video_extention=video_extention,download_directory=download_directory,download=download,get_info=get_info,user_agent=user_agent)
-        elif VideoDownloaderSingleton._instance.title != title or video_extention != VideoDownloaderSingleton._instance.video_extention or url != VideoDownloaderSingleton._instance.url or download_directory != VideoDownloaderSingleton._instance.download_directory or user_agent != VideoDownloaderSingleton._instance.user_agent:
-            VideoDownloaderSingleton._instance = VideoDownloader(url=url,title=title,video_extention=video_extention,download_directory=download_directory,download=download,get_info=get_info,user_agent=user_agent)
-        return VideoDownloaderSingleton._instance
+def safe_json_loads(data):
+    try:
+        return json.loads(data)
+    except json.JSONDecodeError:
+        return None
+def convert_to_json(obj):
+    if isinstance(obj, dict):
+        return obj
+    if isinstance(obj, str):
+        return safe_json_loads(obj)
+    return None
 class URLManager:
-    def __init__(self, url, session=requests):
+    def __init__(self, url=None, session=requests):
+        if url==None:
+            url='www.example.com'
         self.url = url
         self.session = session
         
@@ -983,7 +528,225 @@ class URLManagerSingleton:
         elif URLManagerSingleton._instance.session != session or URLManagerSingleton._instance.url != url:
             URLManagerSingleton._instance = URLManager(url,session=session)
         return URLManagerSingleton._instance
+class SafeRequest:
+    def __init__(self,
+                 url=None,
+                 url_manager=None,
+                 network_manager=None,
+                 user_agent_manager=None,
+                 ssl_manager=None,
+                 tls_adapter=None,
+                 user_agent=None,
+                 proxies=None,
+                 headers=None,
+                 auth=None,
+                 cookies=None,
+                 session=None,
+                 adapter=None,
+                 protocol=None,
+                 ciphers=None,
+                 certification=None,
+                 ssl_options=None,
+                 stream=False,
+                 last_request_time=None,
+                 max_retries=None,
+                 request_wait_limit=None):
+        if url_manager == None:
+            url_manager = URLManager(url=url)
+        self.url_manager=url_manager
+        if network_manager == None:
+            network_manager=NetworkManager(user_agent_manager=user_agent_manager,ssl_manager=ssl_manager, tls_adapter=tls_adapter,user_agent=user_agent,proxies=proxies,auth=auth,cookies=cookies,ciphers=ciphers, certification=certification, ssl_options=ssl_options)
+        if user_agent_manager == None:
+            user_agent_manager = UserAgentManager(user_agent=user_agent)
+        self.user_agent_manager = user_agent_manager
+        self.user_agent= self.user_agent_manager.user_agent   
+        self.network_manager = network_manager
+        self.tls_adapter=self.network_manager.tls_adapter
+        self.ciphers=self.network_manager.ciphers
+        self.certification=self.network_manager.certification
+        self.ssl_options=self.network_manager.ssl_options
+        self.proxies=self.network_manager.proxies
+        self.auth=self.network_manager.auth
+        self.cookies=self.network_manager.cookies
+        self.session = session or requests.session()
+        self.protocol=protocol or 'https://'
+        self.headers=headers or self.user_agent or {'Accept': '*/*'}
+        self.stream=stream if isinstance(stream,bool) else False
+        self.initialize_session()
+        self.last_request_time=last_request_time
+        self.max_retries = max_retries or 3
+        self.request_wait_limit = request_wait_limit or 1.5
+        self._response=None
+        self.make_request()
+        self.source_code = None
+        self.source_code_bytes=None
+        self.source_code_json = {}
+        self.react_source_code=[]
+        self._response_data = None
+        self.process_response_data()
+    @property
+    def response(self):
+        """Lazy-loading of response."""
+        if self._response is None:
+            self._response = self.fetch_response()
+        return self._response
+    
+    def fetch_response(self) -> Union[requests.Response, None]:
+        """Actually fetches the response from the server."""
+        # You can further adapt this method to use retries or other logic you had
+        # in your original code, but the main goal here is to fetch and return the response
+        return self.try_request()
+    def initialize_session(self):
+        s = self.session  
+        s.proxies = self.network_manager.proxies  # Use the proxies from the NetworkManager
+        s.auth = self.network_manager.auth  # Use the auth from SafeRequest (if provided)
+        # Add any other headers or cookie settings here
+        s.cookies["cf_clearance"] = self.network_manager.cookies
+        s.headers.update(self.headers)
+        s.mount(self.protocol, self.network_manager.tls_adapter)  # Use the TLSAdapter from the NetworkManager
+        return s
+    def process_response_data(self):
+        """Processes the fetched response data."""
+        if not self.response:
+            return  # No data to process
+        
+        self.source_code = self.response.text
+        self.source_code_bytes = self.response.content
+        
+        if self.response.headers.get('content-type') == 'application/json':
+            data = convert_to_json(self.source_code)
+            if data:
+                self.source_code_json = data.get("response", data)
+        
+        self.get_react_source_code()
+    def get_react_source_code(self) -> list:
+        """
+        Fetches the source code of the specified URL and extracts JavaScript and JSX source code (React components).
+
+        Args:
+            url (str): The URL to fetch the source code from.
 
+        Returns:
+            list: A list of strings containing JavaScript and JSX source code found in <script> tags.
+        """
+        if  self.url_manager.correct_url is None:
+            return []
+        soup = BeautifulSoup(self.source_code_bytes,"html.parser")
+        script_tags = soup.find_all('script', type=lambda t: t and ('javascript' in t or 'jsx' in t))
+        for script_tag in script_tags:
+            self.react_source_code.append(script_tag.string)
+
+
+    def get_status(url:str=None) -> int:
+        """
+        Gets the HTTP status code of the given URL.
+
+        Args:
+            url (str): The URL to check the status of.
+
+        Returns:
+            int: The HTTP status code of the URL, or None if the request fails.
+        """
+        # Get the status code of the URL
+        return try_request(url=url).status_code
+    def wait_between_requests(self):
+        """
+        Wait between requests based on the request_wait_limit.
+        """
+        if self.last_request_time:
+            sleep_time = self.request_wait_limit - (get_time_stamp() - self.last_request_time)
+            if sleep_time > 0:
+                logging.info(f"Sleeping for {sleep_time:.2f} seconds.")
+                get_sleep(sleep_time)
+
+    def make_request(self):
+        """
+        Make a request and handle potential errors.
+        """
+        # Update the instance attributes if they are passed
+
+        self.wait_between_requests()
+        for _ in range(self.max_retries):
+            try:
+                self.try_request()  # 10 seconds timeout
+                if self.response:
+                    if self.response.status_code == 200:
+                        self.last_request_time = get_time_stamp()
+                        return self.response
+                    elif self.response.status_code == 429:
+                        logging.warning(f"Rate limited by {self.url_manager.correct_url}. Retrying...")
+                        get_sleep(5)  # adjust this based on the server's rate limit reset time
+            except requests.Timeout as e:
+                logging.error(f"Request to {cleaned_url} timed out: {e}")
+            except requests.ConnectionError:
+                logging.error(f"Connection error for URL {self.url_manager.correct_url}.")
+            except requests.Timeout:
+                logging.error(f"Request timeout for URL {self.url_manager.correct_url}.")
+            except requests.RequestException as e:
+                logging.error(f"Request exception for URL {self.url_manager.correct_url}: {e}")
+
+        logging.error(f"Failed to retrieve content from {self.url_manager.correct_url} after {self.max_retries} retries.")
+        return None
+    def try_request(self, timeout=10) -> Union[requests.Response, None]:
+        """
+        Tries to make an HTTP request to the given URL using the provided session.
+
+        Args:
+            timeout (int): Timeout for the request.
+
+        Returns:
+            requests.Response or None: The response object if the request is successful, or None if the request fails.
+        """
+        try:
+            return self.session.get(url=self.url_manager.url, timeout=timeout)
+        except requests.exceptions.RequestException as e:
+            print(e)
+            return None
+
+    def get_limited_request(self,request_url,service_name="default"):
+        manager = DynamicRateLimiterManagerSingleton.get_instance()  # Get the singleton instance
+        unwanted_response=True
+        # Check with the rate limiter if we can make a request
+        while True:
+            if not manager.request(service_name):
+                print("Rate limit reached for coin_gecko. Waiting for the next epoch...")
+                sleep_count_down(manager.services[service_name].get_sleep()["current_sleep"])  # Wait for the limit_epoch duration
+            # Make the actual request
+            response = try_request(request_url=request_url)
+            
+            # If you get a rate-limit error (usually 429 status code but can vary), adjust the rate limiter
+            if response.status_code ==429:
+                print(response.json())
+                manager.services[service_name].request_tracker(False)
+                print("Rate limited by coin_gecko. Adjusted limit. Retrying...")
+                if len(manager.services[service_name].calculate_tokens()["succesful"])<2:
+                    sleep_count_down(manager.services[service_name].limit_epoch)  # Wait for the limit_epoch duration
+                else:
+                    manager.services[service_name].current_limit-=1
+                    sleep_count_down(manager.services[service_name].limit_epoch/len(manager.services[service_name].calculate_tokens()["succesful"]))  # Wait for the limit_epoch duration
+            # Return the data if the request was successful
+            if response.status_code == 200:
+                manager.services[service_name].request_tracker(True)
+                return response.json()
+            elif response.status_code not in [200,429]:
+                print(f"Unexpected response: {response.status_code}. Message: {response.text}")
+                return None
+    @property
+    def url(self):
+        return self.url_manager.url
+
+    @url.setter
+    def url(self, new_url):
+        self._url_manager.url = new_url
+class SafeRequestSingleton:
+    _instance = None
+    @staticmethod
+    def get_instance(url=None,headers:dict=None,max_retries=3,last_request_time=None,request_wait_limit=1.5):
+        if SafeRequestSingleton._instance is None:
+            SafeRequestSingleton._instance = SafeRequest(url,url_manager=URLManagerSingleton,headers=headers,max_retries=max_retries,last_request_time=last_request_time,request_wait_limit=request_wait_limit)
+        elif SafeRequestSingleton._instance.url != url or SafeRequestSingleton._instance.headers != headers or SafeRequestSingleton._instance.max_retries != max_retries or SafeRequestSingleton._instance.request_wait_limit != request_wait_limit:
+            SafeRequestSingleton._instance = SafeRequest(url,url_manager=URLManagerSingleton,headers=headers,max_retries=max_retries,last_request_time=last_request_time,request_wait_limit=request_wait_limit)
+        return SafeRequestSingleton._instance
 class SoupManager:
     def __init__(self,url_manager,request_manager, parse_type="html.parser"):
         self.soup=[]
@@ -1188,6 +951,172 @@ class SoupManager:
     @url.setter
     def url(self, new_url):
         self._url = new_url
+
+class SoupManagerSingleton():
+    _instance = None
+    @staticmethod
+    def get_instance(url_manager,request_manager,parse_type="html.parser",source_code=None):
+        if SoupManagerSingleton._instance is None:
+            SoupManagerSingleton._instance = SoupManager(url_manager,request_manager,parse_type=parse_type,source_code=source_code)
+        elif parse_type != SoupManagerSingleton._instance.parse_type  or source_code != SoupManagerSingleton._instance.source_code:
+            SoupManagerSingleton._instance = SoupManager(url_manager,request_manager,parse_type=parse_type,source_code=source_code)
+        return SoupManagerSingleton._instance
+class VideoDownloader:
+    def __init__(self, url,title=None,download_directory=os.getcwd(),user_agent=None,video_extention='mp4',download_video=True,get_info=False,auto_file_gen=True,standalone_download=False):
+        self.url=url
+        self.monitoring = True
+        self.downloading = True
+        self.pause_event = threading.Event()
+        self.get_download = download_video
+        self.get_info = get_info
+        self.user_agent=user_agent
+        self.title = title
+        self.auto_file_gen=auto_file_gen
+        self.standalone_download=standalone_download
+        self.video_extention=video_extention
+        self.download_directory=download_directory
+        self.video_extention=video_extention
+        self.header = {}#UserAgentManagerSingleton().get_instance(user_agent=user_agent)
+        self.base_name = os.path.basename(self.url)
+        self.file_name,self.ext = os.path.splitext(self.base_name)
+        self.video_urls = [self.url]
+        self.info={}
+        self.starttime = None
+        self.downloaded = 0
+        self.video_urls = url if isinstance(url,list) else [url]
+        self.send_to_dl()
+
+    def get_request(self,url):
+        self.request_manager = SafeRequestSingleton.get_instance(url=url)
+        return self.request_manager
+    def send_to_dl(self):
+        if self.standalone_download:
+            self.standalone_downloader()
+        else:
+            self.start()
+    def get_headers(self,url):
+        # Send an HTTP GET request to the URL
+        response = requests.get(url)
+        # Check if the request was successful (status code 200)
+        if response.status_code == 200:
+            # Access and print the response headers
+            return response.headers
+        else:
+            print(f"Failed to retrieve the web page. Status code: {response.status_code}")
+    def progress_callback(self, stream, chunk, bytes_remaining):
+        total_size = stream.filesize
+        self.downloaded = total_size - bytes_remaining
+    def get_directory_path(directory,name,video_extention):
+        file_path=os.path.join(directory,name+'.'+video_extention)
+        i=0
+        while os.path.exists(file_path) == True:
+            file_path=os.path.join(directory,name+f'_{i}'+'.'+video_extention)
+            i+=1
+        return file_path
+    def fetch_video_urls(self):
+        driver = webdriver.Chrome()
+        driver.get(self.url)
+        self.page_source = driver.page_source
+        for each in self.page_source.split('<source ')[1:]:
+            self.video_urls.append(eatInner(each.split('.{self.video_extention}'.replace('..','.'))[0].split('http')[-1],['h','t','t','p','s',':','//','/','s','=',' ','\n','\t',''])+'.mp4')
+    def download(self):
+        def downloading_while():
+            while self.downloading:
+                self.pause_event.wait(3)
+                print('downloading...')
+        for video_url in self.video_urls:
+            ydl_opts = {
+              'external_downloader': 'ffmpeg',
+              'external_downloader_args': "-ss 00:01:00.00 -to 00:02:00.00",
+              'format': 'best',
+              'outtmpl': f'{self.download_directory} %(title)s-%(id)s.%(ext)s',
+              'noprogress': True
+            }
+            self.output_video = ydl_opts['outtmpl']
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                self.downloading_while = threading.Thread(target=downloading_while)
+                self.downloading_while.start()
+                self.info = ydl.extract_info(video_url, download=self.get_download)
+                self.downloading=False
+                self.starttime = get_time_stamp()
+                if self.auto_file_gen:
+                    file_path = ydl.prepare_filename(self.info)
+                    if self.get_info == True:
+                        self.info['file_path']=file_path
+                if self.get_info == True:
+                    self.stop()
+                    return self.info
+        self.stop()
+        return self.info
+    def monitor(self):
+        name =  self.title or False
+        while self.monitoring:
+            print("Monitoring...")
+            self.pause_event.wait(60)  # check every minute
+            if self.starttime:
+                elapsed_time = get_time_stamp() - self.starttime
+                if self.downloaded != 0 and elapsed_time !=0:
+                    percent = self.downloaded / (self.downloaded + elapsed_time)
+                else:
+                    percent = 0
+                if elapsed_time !=0:
+                    try:
+                        # operations that can cause ZeroDivisionError
+                        percent = self.downloaded / (self.downloaded + elapsed_time)
+                        downloaded_minutes = elapsed_time / 60
+                        estimated_download_time = downloaded_minutes / percent - downloaded_minutes
+                    except ZeroDivisionError:
+                        print("Caught a division by zero!")
+                        continue
+
+                if downloaded_minutes != 0 and (percent - downloaded_minutes) !=0:
+                    estimated_download_time = downloaded_minutes / percent - downloaded_minutes
+                    print(estimated_download_time)
+                if estimated_download_time >= 1.5:
+                    print("Seems like YouTube is limiting our download speed, restarting the download to mitigate the problem..")
+                    # TODO: Find a way to stop the current download and restart. This may not work efficiently since pytube doesn't expose a cancel download method.
+                    self.start()  # Restart the download process
+    def standalone_downloader(self):
+        name = self.title or False
+        fetch_video_urls()
+        for video_url in self.video_urls:
+                self.request_manager
+                self.info=True
+                self.download_video=False
+                headers = self.get_headers(video_url)
+                for v in soup.select("video source[src]"):
+                    print("Downloading {}".format(v["src"]))
+                    if not name_chosen:
+                        name = v["src"].split("/")[-1].strip()
+                    file_path = get_directory_path(directory,name,video_extention)
+                    print(f"saving to {file_path}")
+                    with open(get_directory_path(directory,name,video_extention), "wb") as f_out:
+                        f_out.write(requests.get(v["src"].strip(), headers=headers).content)
+      
+    def start(self):
+        self.download_thread = threading.Thread(target=self.download)
+        self.download_thread.daemon = True
+        self.monitor_thread = threading.Thread(target=self.monitor)
+        self.download_thread.start()
+        self.monitor_thread.start()
+        self.download_thread.join()
+        self.monitor_thread.join()
+    def stop(self):
+        self.monitoring = False
+        self.pause_event.set()
+
+
+
+class VideoDownloaderSingleton():
+    _instance = None
+    @staticmethod
+    def get_instance(url_manager,request_manager,title=None,video_extention='mp4',download_directory=os.getcwd(),user_agent=None,download=True,get_info=False):
+        if VideoDownloaderSingleton._instance is None:
+            VideoDownloaderSingleton._instance = VideoDownloader(url=url,title=title,video_extention=video_extention,download_directory=download_directory,download=download,get_info=get_info,user_agent=user_agent)
+        elif VideoDownloaderSingleton._instance.title != title or video_extention != VideoDownloaderSingleton._instance.video_extention or url != VideoDownloaderSingleton._instance.url or download_directory != VideoDownloaderSingleton._instance.download_directory or user_agent != VideoDownloaderSingleton._instance.user_agent:
+            VideoDownloaderSingleton._instance = VideoDownloader(url=url,title=title,video_extention=video_extention,download_directory=download_directory,download=download,get_info=get_info,user_agent=user_agent)
+        return VideoDownloaderSingleton._instance
+
 class LinkManager:
     def __init__(self,url_manager,soup_manager,img_attr_value_desired=None,img_attr_value_undesired=None,link_attr_value_desired=None,link_attr_value_undesired=None,associated_data_attr=["data-title",'alt','title'],get_img=["data-title",'alt','title']):
         self.url_manager= url_manager
@@ -1254,15 +1183,7 @@ class LinkManager:
                 valid_assiciated_attrs[-1]["link"]=valid_attr
         desired_links.append(valid_assiciated_attrs)
         return desired_links
-class SoupManagerSingleton():
-    _instance = None
-    @staticmethod
-    def get_instance(url_manager,request_manager,parse_type="html.parser",source_code=None):
-        if SoupManagerSingleton._instance is None:
-            SoupManagerSingleton._instance = SoupManager(url_manager,request_manager,parse_type=parse_type,source_code=source_code)
-        elif parse_type != SoupManagerSingleton._instance.parse_type  or source_code != SoupManagerSingleton._instance.source_code:
-            SoupManagerSingleton._instance = SoupManager(url_manager,request_manager,parse_type=parse_type,source_code=source_code)
-        return SoupManagerSingleton._instance
+
 def CrawlManager():
     def __init__(self,url=None,source_code=None,parse_type="html.parser"):
         self.url=url
@@ -1450,4 +1371,3 @@ class CrawlManagerSingleton():
         elif parse_type != CrawlManagerSingleton._instance.parse_type or url != CrawlManagerSingleton._instance.url  or source_code != CrawlManagerSingleton._instance.source_code:
             CrawlManagerSingleton._instance = CrawlManager(url=url,parse_type=parse_type,source_code=source_code)
         return CrawlManagerSingleton._instance
-