abstract-webtools 0.1.6.136__py3-none-any.whl → 0.1.6.138__py3-none-any.whl

abstract_webtools/managers/seleniumManager.py

@@ -21,7 +21,7 @@ from selenium.webdriver.chrome.options import Options
 
 # Setup Chrome options
 chrome_options = Options()
-chrome_options.binary_location = "/home/profiles/solcatcher/.cache/selenium/chrome/linux64/130.0.6723.58/chrome"
+#chrome_options.binary_location = "/home/profiles/solcatcher/.cache/selenium/chrome/linux64/130.0.6723.58/chrome"
 chrome_options.add_argument("--headless")  # Run in headless mode
 chrome_options.add_argument("--no-sandbox")
 chrome_options.add_argument("--disable-dev-shm-usage")

abstract_webtools/managers/urlManager/urlManager (Copy).py

@@ -0,0 +1,220 @@
+import re
+import urllib.parse
+import requests
+from urllib.parse import urlparse, urlunparse, urljoin
+
+from ...abstract_webtools import *
+
+class urlManager:
+    """
+    Revised urlManager for managing and cleaning URLs.
+    
+    It splits URLs into their components, normalizes them (trimming spaces, lowercasing
+    scheme and domain, removing default ports, and cleaning up paths), and then creates
+    a list of potential variants (with/without www, http/https) so that a valid version
+    can be determined.
+    """
+    def __init__(self, url=None, session=None):
+        url = url or 'www.example.com'
+        self._url = url
+        self.session = session or requests
+        self.clean_urls = self.clean_url(url)
+        self.url = self.get_correct_url(clean_urls=self.clean_urls) or url
+        self.protocol, self.domain, self.path, self.query = self.url_to_pieces(self.url)
+        self.all_urls = []
+    
+    def url_to_pieces(self, url):
+        """
+        Split a URL into protocol, domain, path, and query components.
+        Uses urlparse for robustness.
+        """
+        try:
+            parsed = urlparse(url)
+            protocol = parsed.scheme if parsed.scheme else None
+            domain = parsed.netloc if parsed.netloc else None
+            path = parsed.path or ""
+            query = parsed.query or ""
+        except Exception as e:
+            print(f'The URL {url} was not reachable: {e}')
+            protocol, domain, path, query = None, None, "", ""
+        return protocol, domain, path, query
+
+    def clean_url(self, url=None) -> list:
+        """
+        Normalize and clean the URL, then return a list of potential URL variants.
+        
+        This method:
+          - Strips whitespace.
+          - Adds a scheme (defaults to https) if missing.
+          - Lowercases the scheme and domain.
+          - Removes default ports.
+          - Cleans up the path (removing duplicate slashes and trailing slash).
+          - Generates variants with and without 'www', and with both http and https.
+        """
+        url = url or self._url
+        url = url.strip()
+        # Ensure the URL has a scheme
+        if not re.match(r'https?://', url):
+            url = 'https://' + url
+
+        parsed = urlparse(url)
+        scheme = parsed.scheme.lower()
+        netloc = parsed.netloc.lower()
+        # Remove default port numbers if present
+        if ':' in netloc:
+            host, port = netloc.split(':', 1)
+            if (scheme == "http" and port == "80") or (scheme == "https" and port == "443"):
+                netloc = host
+        
+        # Normalize the path: remove duplicate slashes and a trailing slash
+        path = re.sub(r'//+', '/', parsed.path).rstrip('/')
+        
+        # Rebuild the cleaned URL without query or fragment
+        cleaned_url = urlunparse((scheme, netloc, path, '', '', ''))
+        
+        variants = []
+        # Add the primary variant
+        variants.append(cleaned_url)
+        # Generate a variant with/without 'www'
+        if netloc.startswith('www.'):
+            no_www = netloc[4:]
+            variants.append(urlunparse((scheme, no_www, path, '', '', '')))
+        else:
+            variants.append(urlunparse((scheme, f"www.{netloc}", path, '', '', '')))
+        
+        # Also generate variants with the alternate scheme
+        alt_scheme = 'http' if scheme == 'https' else 'https'
+        for variant in list(variants):
+            parsed_variant = urlparse(variant)
+            alt_variant = urlunparse((alt_scheme, parsed_variant.netloc, parsed_variant.path, '', '', ''))
+            variants.append(alt_variant)
+        
+        # Remove duplicates while preserving order
+        seen = set()
+        unique_variants = []
+        for v in variants:
+            if v not in seen:
+                unique_variants.append(v)
+                seen.add(v)
+        return unique_variants
+
+    def get_correct_url(self, url=None, clean_urls=None) -> str:
+        """
+        Attempts each URL variant by making an HTTP GET request.
+        Returns the first variant that returns a 200 OK response.
+        """
+        if url is None and clean_urls is None:
+            url = self._url
+            clean_urls = self.clean_urls
+        if url is not None and clean_urls is None:
+            clean_urls = self.clean_url(url)
+        elif url is None and clean_urls is not None:
+            url = self._url
+
+        for candidate in clean_urls:
+            try:
+                response = self.session.get(candidate, timeout=5)
+                if response.status_code == 200:
+                    return candidate
+            except requests.exceptions.RequestException as e:
+                print(f"Failed to reach {candidate}: {e}")
+        return None
+
+    def update_url(self, url):
+        """
+        Update the URL and refresh related attributes.
+        """
+        self._url = url
+        self.clean_urls = self.clean_url(url)
+        self.url = self.get_correct_url(clean_urls=self.clean_urls) or url
+        self.protocol, self.domain, self.path, self.query = self.url_to_pieces(self.url)
+        self.all_urls = []
+
+    def get_domain(self, url=None):
+        url = url or self.url
+        return urlparse(url).netloc
+
+    def url_join(self, base_url, path):
+        """
+        Joins a base URL with a relative path.
+        """
+        base_url = base_url.strip().rstrip('/')
+        path = path.strip().lstrip('/')
+        return f"{base_url}/{path}"
+
+    @property
+    def url(self):
+        return self._url
+
+    @url.setter
+    def url(self, new_url):
+        self._url = new_url
+
+    def is_valid_url(self, url=None):
+        """
+        Check if the given URL is valid.
+        """
+        url = url or self.url
+        parsed = urlparse(url)
+        return bool(parsed.scheme) and bool(parsed.netloc)
+    
+    def make_valid(self, href, url=None):
+        """
+        Validate a href. If it's not already valid, join it with the base URL.
+        """
+        if self.is_valid_url(href):
+            return href
+        base = url or self.url
+        new_link = urljoin(base, href)
+        if self.is_valid_url(new_link):
+            return new_link
+        return False
+
+    def get_relative_href(self, base, href):
+        """
+        For a relative href, join it with the base URL and strip any query or fragment.
+        """
+        joined = urljoin(base, href)
+        parsed = urlparse(joined)
+        clean_href = urlunparse((parsed.scheme, parsed.netloc, parsed.path, '', '', ''))
+        return clean_href
+
+    def url_basename(self, url=None):
+        url = url or self.url
+        path = urlparse(url).path
+        return path.strip('/').split('/')[-1]
+
+    def base_url(self, url=None):
+        url = url or self.url
+        match = re.match(r'https?://[^?#/]+/', url)
+        if match:
+            return match.group()
+        return None
+
+    def urljoin(self, base, path):
+        return urljoin(base, path)
+
+class urlManagerSingleton:
+    _instance = None
+
+    @staticmethod
+    def get_instance(url=None, session=requests):
+        if urlManagerSingleton._instance is None:
+            urlManagerSingleton._instance = urlManager(url, session=session)
+        elif urlManagerSingleton._instance.session != session or urlManagerSingleton._instance.url != url:
+            urlManagerSingleton._instance = urlManager(url, session=session)
+        return urlManagerSingleton._instance
+
+def get_url(url=None, url_mgr=None):
+    if not url and not url_mgr:
+        return None
+    if url:
+        url_mgr = urlManager(url)
+    return url_mgr.url
+
+def get_url_mgr(url=None, url_mgr=None):
+    if url_mgr is None and url:
+         url_mgr = urlManager(url=url)
+    if url_mgr and url is None:
+        url = url_mgr.url
+    return url_mgr

abstract_webtools/managers/urlManager/urlManager.py

@@ -1,9 +1,9 @@
 import re
-import urllib.parse
+import logging
 import requests
 from urllib.parse import urlparse, urlunparse, urljoin
 
-from ...abstract_webtools import *
+logging.basicConfig(level=logging.INFO)
 
 class urlManager:
     """
@@ -13,30 +13,38 @@ class urlManager:
     scheme and domain, removing default ports, and cleaning up paths), and then creates
     a list of potential variants (with/without www, http/https) so that a valid version
     can be determined.
+    
+    Now handles url=None gracefully: sets internals to None/empty and methods return None or empty values without errors.
     """
     def __init__(self, url=None, session=None):
-        url = url or 'www.example.com'
-        self._url = url
-        self.session = session or requests
-        self.clean_urls = self.clean_url(url)
-        self.url = self.get_correct_url(clean_urls=self.clean_urls) or url
-        self.protocol, self.domain, self.path, self.query = self.url_to_pieces(self.url)
-        self.all_urls = []
-    
+        self._url = url  # Allow None
+        self.session = session or requests.Session()
+        if self._url is None:
+            self.clean_urls = []
+            self.url = None
+            self.protocol = None
+            self.domain = None
+            self.path = ""
+            self.query = ""
+            self.all_urls = []
+        else:
+            self.clean_urls = self.clean_url()
+            self.url = self.get_correct_url() or self._url
+            self.protocol, self.domain, self.path, self.query = self.url_to_pieces(self.url)
+            self.all_urls = []
+
     def url_to_pieces(self, url):
         """
         Split a URL into protocol, domain, path, and query components.
         Uses urlparse for robustness.
         """
-        try:
-            parsed = urlparse(url)
-            protocol = parsed.scheme if parsed.scheme else None
-            domain = parsed.netloc if parsed.netloc else None
-            path = parsed.path or ""
-            query = parsed.query or ""
-        except Exception as e:
-            print(f'The URL {url} was not reachable: {e}')
-            protocol, domain, path, query = None, None, "", ""
+        if url is None:
+            return None, None, "", ""
+        parsed = urlparse(url)
+        protocol = parsed.scheme or None
+        domain = parsed.netloc or None
+        path = parsed.path or ""
+        query = parsed.query or ""
         return protocol, domain, path, query
 
     def clean_url(self, url=None) -> list:
@@ -48,15 +56,19 @@ class urlManager:
           - Adds a scheme (defaults to https) if missing.
           - Lowercases the scheme and domain.
           - Removes default ports.
-          - Cleans up the path (removing duplicate slashes and trailing slash).
+          - Cleans up the path (removing duplicate slashes and trailing slash if not a file-like path).
+          - Preserves params and query; strips fragment.
           - Generates variants with and without 'www', and with both http and https.
         """
-        url = url or self._url
+        url = (url or self._url)  # Use self._url if url None
+        if url is None:
+            return []
         url = url.strip()
+        if not url:
+            return []
         # Ensure the URL has a scheme
-        if not re.match(r'https?://', url):
+        if not re.match(r'https?://', url, re.IGNORECASE):
             url = 'https://' + url
-
         parsed = urlparse(url)
         scheme = parsed.scheme.lower()
         netloc = parsed.netloc.lower()
@@ -66,58 +78,55 @@ class urlManager:
             if (scheme == "http" and port == "80") or (scheme == "https" and port == "443"):
                 netloc = host
         
-        # Normalize the path: remove duplicate slashes and a trailing slash
-        path = re.sub(r'//+', '/', parsed.path).rstrip('/')
+        # Normalize the path: remove duplicate slashes; rstrip '/' only if path isn't root or file-like
+        path = re.sub(r'//+', '/', parsed.path)
+        if path != '/' and '.' not in path.split('/')[-1]:  # Fixed: check if last segment has '.' for file-like
+            path = path.rstrip('/')
         
-        # Rebuild the cleaned URL without query or fragment
-        cleaned_url = urlunparse((scheme, netloc, path, '', '', ''))
+        # Rebuild the cleaned URL, preserving params and query, stripping fragment
+        cleaned_url = urlunparse((scheme, netloc, path, parsed.params, parsed.query, ''))
         
-        variants = []
-        # Add the primary variant
-        variants.append(cleaned_url)
+        variants = [cleaned_url]
         # Generate a variant with/without 'www'
         if netloc.startswith('www.'):
             no_www = netloc[4:]
-            variants.append(urlunparse((scheme, no_www, path, '', '', '')))
+            variants.append(urlunparse((scheme, no_www, path, parsed.params, parsed.query, '')))
         else:
-            variants.append(urlunparse((scheme, f"www.{netloc}", path, '', '', '')))
+            variants.append(urlunparse((scheme, f"www.{netloc}", path, parsed.params, parsed.query, '')))
         
-        # Also generate variants with the alternate scheme
+        # Generate variants with the alternate scheme
         alt_scheme = 'http' if scheme == 'https' else 'https'
         for variant in list(variants):
             parsed_variant = urlparse(variant)
-            alt_variant = urlunparse((alt_scheme, parsed_variant.netloc, parsed_variant.path, '', '', ''))
+            alt_variant = urlunparse((alt_scheme, parsed_variant.netloc, parsed_variant.path, parsed_variant.params, parsed_variant.query, ''))
             variants.append(alt_variant)
         
         # Remove duplicates while preserving order
         seen = set()
-        unique_variants = []
-        for v in variants:
-            if v not in seen:
-                unique_variants.append(v)
-                seen.add(v)
+        unique_variants = [v for v in variants if v not in seen and not seen.add(v)]
+        
+        # Sort to prefer HTTPS variants first
+        unique_variants.sort(key=lambda v: (not v.startswith('https'), v))
         return unique_variants
 
     def get_correct_url(self, url=None, clean_urls=None) -> str:
         """
-        Attempts each URL variant by making an HTTP GET request.
+        Attempts each URL variant by making an HTTP HEAD request (lighter than GET).
         Returns the first variant that returns a 200 OK response.
         """
-        if url is None and clean_urls is None:
-            url = self._url
-            clean_urls = self.clean_urls
-        if url is not None and clean_urls is None:
+        if self._url is None:
+            return None
+        clean_urls = clean_urls or self.clean_urls
+        url = url or self._url
+        if not clean_urls:
             clean_urls = self.clean_url(url)
-        elif url is None and clean_urls is not None:
-            url = self._url
-
         for candidate in clean_urls:
             try:
-                response = self.session.get(candidate, timeout=5)
+                response = self.session.head(candidate, timeout=5, allow_redirects=True)
                 if response.status_code == 200:
                     return candidate
             except requests.exceptions.RequestException as e:
-                print(f"Failed to reach {candidate}: {e}")
+                logging.info(f"Failed to reach {candidate}: {e}")
         return None
 
     def update_url(self, url):
@@ -125,23 +134,26 @@ class urlManager:
         Update the URL and refresh related attributes.
         """
         self._url = url
-        self.clean_urls = self.clean_url(url)
-        self.url = self.get_correct_url(clean_urls=self.clean_urls) or url
-        self.protocol, self.domain, self.path, self.query = self.url_to_pieces(self.url)
-        self.all_urls = []
+        if self._url is None:
+            self.clean_urls = []
+            self.url = None
+            self.protocol = None
+            self.domain = None
+            self.path = ""
+            self.query = ""
+            self.all_urls = []
+        else:
+            self.clean_urls = self.clean_url(url)
+            self.url = self.get_correct_url() or url
+            self.protocol, self.domain, self.path, self.query = self.url_to_pieces(self.url)
+            self.all_urls = []
 
     def get_domain(self, url=None):
+        if self._url is None and url is None:
+            return None
         url = url or self.url
         return urlparse(url).netloc
 
-    def url_join(self, base_url, path):
-        """
-        Joins a base URL with a relative path.
-        """
-        base_url = base_url.strip().rstrip('/')
-        path = path.strip().lstrip('/')
-        return f"{base_url}/{path}"
-
     @property
     def url(self):
         return self._url
@@ -154,51 +166,68 @@ class urlManager:
         """
         Check if the given URL is valid.
         """
+        if url is None and self._url is None:
+            return False
         url = url or self.url
+        if url is None:
+            return False
         parsed = urlparse(url)
         return bool(parsed.scheme) and bool(parsed.netloc)
-    
+
     def make_valid(self, href, url=None):
         """
         Validate a href. If it's not already valid, join it with the base URL.
         """
+        if self._url is None and url is None:
+            return None
         if self.is_valid_url(href):
             return href
         base = url or self.url
+        if base is None:
+            return None
         new_link = urljoin(base, href)
         if self.is_valid_url(new_link):
             return new_link
-        return False
+        return None
 
     def get_relative_href(self, base, href):
         """
         For a relative href, join it with the base URL and strip any query or fragment.
         """
+        if base is None:
+            return None
         joined = urljoin(base, href)
         parsed = urlparse(joined)
         clean_href = urlunparse((parsed.scheme, parsed.netloc, parsed.path, '', '', ''))
         return clean_href
 
     def url_basename(self, url=None):
+        if self._url is None and url is None:
+            return ""
         url = url or self.url
+        if url is None:
+            return ""
         path = urlparse(url).path
         return path.strip('/').split('/')[-1]
 
     def base_url(self, url=None):
+        if self._url is None and url is None:
+            return None
         url = url or self.url
-        match = re.match(r'https?://[^?#/]+/', url)
-        if match:
-            return match.group()
-        return None
+        if url is None:
+            return None
+        parsed = urlparse(url)
+        return urlunparse((parsed.scheme, parsed.netloc, '/', '', '', ''))
 
     def urljoin(self, base, path):
+        if base is None:
+            return None
         return urljoin(base, path)
 
 class urlManagerSingleton:
     _instance = None
-
     @staticmethod
-    def get_instance(url=None, session=requests):
+    def get_instance(url=None, session=requests.Session()):
         if urlManagerSingleton._instance is None:
             urlManagerSingleton._instance = urlManager(url, session=session)
         elif urlManagerSingleton._instance.session != session or urlManagerSingleton._instance.url != url:
@@ -208,13 +237,13 @@ class urlManagerSingleton:
 def get_url(url=None, url_mgr=None):
     if not url and not url_mgr:
         return None
-    if url:
+    if url_mgr is None and url is not None:
         url_mgr = urlManager(url)
-    return url_mgr.url
+    return url_mgr.url if url_mgr else None
 
 def get_url_mgr(url=None, url_mgr=None):
-    if url_mgr is None and url:
-         url_mgr = urlManager(url=url)
+    if url_mgr is None:
+        url_mgr = urlManager(url=url)  # Always create instance, even if url=None
     if url_mgr and url is None:
         url = url_mgr.url
     return url_mgr

{abstract_webtools-0.1.6.136.dist-info → abstract_webtools-0.1.6.138.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_webtools
-Version: 0.1.6.136
+Version: 0.1.6.138
 Summary: Abstract Web Tools is a Python package that provides various utility functions for web scraping tasks. It is built on top of popular libraries such as `requests`, `BeautifulSoup`, and `urllib3` to simplify the process of fetching and parsing web content.
 Home-page: https://github.com/AbstractEndeavors/abstract_essentials/tree/main/abstract_webtools
 Author: putkoff

{abstract_webtools-0.1.6.136.dist-info → abstract_webtools-0.1.6.138.dist-info}/RECORD

@@ -1,5 +1,4 @@
 abstract_webtools/__init__.py,sha256=ubqE7spnA8YUcPkXP1-niLIuza07_GGIq2ww3d2Gdsk,118
-abstract_webtools/abstract_userpit.py,sha256=Rg_0Orx79rxqEePt6Sf-evGslPq5KLlTiL-P2w1u6ng,6462
 abstract_webtools/abstract_usurpit.py,sha256=2idbYXLFhXh8VPfdYgWICNH8dehnZRCdt4U5sTsVxo4,9663
 abstract_webtools/abstract_webtools.py,sha256=3NzGmJlZvrdVtEcUi2K5iUgWr1822IBPhIN9us2e2t0,3859
 abstract_webtools/big_user_agent_list.py,sha256=5ZkrUWmfzYL5yaULREslh9ZiRQeITbSjqZlp2KQON3w,131923
@@ -11,7 +10,6 @@ abstract_webtools/main.py,sha256=_I7pPXPkoLZOoYGLQDrSLGhGuQt6-PVyXEHZSmglk2g,132
 abstract_webtools/soup_gui.py,sha256=n95YAps1R6DpMwR4UbthSqQby0C5WHUa9tsW-f2qpLg,5184
 abstract_webtools/url_grabber.py,sha256=pnCCev7ZIuM-6cAGTLmK5HfzZg_AX-fLcRpB6ZE70B8,10441
 abstract_webtools/url_grabber_new.py,sha256=xb23qo4anOY0Ax3CAfaHJ8s5VEz61Sinh-XpEDFW7Is,3621
-abstract_webtools/__pycache__/abstract_webtools.cpython-312.pyc,sha256=Rb2nPDCUG6i7nEs-I128lozwKteIVXzZxygV-zJVALs,4606
 abstract_webtools/managers/__init__.py,sha256=9pgy52NB-ONxLqoCRF52GZ6G7GM6Uc0-fgA1HvKcwxc,407
 abstract_webtools/managers/allss\.py,sha256=IBhlyRQHfK-BtwUnSEbIPqlI1MtZ8-XsdaHv0b91HQ0,269
 abstract_webtools/managers/cipherManager.py,sha256=NHQGdR11eNSm-1H-GezD5dyQgsPTJwY5kczt8Sher2s,1621
@@ -21,15 +19,11 @@ abstract_webtools/managers/curlMgr.py,sha256=ghi0QsSAxjZu3HALFST5Kv_262XhHSAPGlQ
 abstract_webtools/managers/domainManager.py,sha256=95znOBv05W77mW_fbZAfl4RmlENDlYqhEOMkL02L220,3610
 abstract_webtools/managers/dynamicRateLimiter.py,sha256=ycn5VQEPnmxjNMew4IVh-t5t43jhM39uypoOK9bJDDg,7662
 abstract_webtools/managers/get_test.py,sha256=nISrhUGdyvRv18wTGoifGhizBFoHeK0N3FymMASloFw,825
-abstract_webtools/managers/linkManager.py,sha256=m6y9s8jknrTX8RtOAFKeHd4yd23G7Rgf0T7Sp7wmHUw,12180
 abstract_webtools/managers/mySocketClient.py,sha256=-j1Q8Ds9RCSbjZdx3ZF9mVpgwxaO0BBssanUcpYVQoY,2045
 abstract_webtools/managers/networkManager.py,sha256=Op2QDXrP-gmm0tCToe-Ryt9xuOtMppcN2KLKP1WZiu0,952
-abstract_webtools/managers/requestManager.py,sha256=zXD31WAYghV1OjnTQzRQnQGqZz6_J4mjHTdNLnBop_0,17343
-abstract_webtools/managers/seleniumManager.py,sha256=qSY8gH3N5YJIMwE_Alj9HNQRip_PziIo4_T9AZE_FQo,4273
-abstract_webtools/managers/soupManager.py,sha256=-_mRCWlyzfKlF64UU53WXBmCvJ98jQ4GyHh8S8Pw3xs,17198
+abstract_webtools/managers/seleniumManager.py,sha256=RRpA1_oOnZuzzQ4S6VX7tDFcI31E_mOou2CZOOZH6yI,4274
 abstract_webtools/managers/sslManager.py,sha256=C-QgQw9CW84uOE5kx2MPjC3RsLbE2JQqdwdTs0H4ecc,1370
 abstract_webtools/managers/tlsAdapter.py,sha256=XZSMZz9EUOhv-h3_Waf6mjV1dA3oN_M_oWuoo4VZ_HE,1454
-abstract_webtools/managers/urlManager.py,sha256=Dvf-TiSo5j_YjZS2Eq6lFfbhveneD6NA_wEE0xUXy_E,8858
 abstract_webtools/managers/userAgentManager.py,sha256=cUaOlcCTzftVBCp9ZHwMXR9IB1wAE-03YSVwUBaIFLM,2514
 abstract_webtools/managers/videoDownloader.py,sha256=mKXhKYNnJwPaiqAsHvFTBGLdXFgR3wdV0G1OIimiKbE,15424
 abstract_webtools/managers/videoDownloader2.py,sha256=v3H6akdhvVWGrB-r35m3cp_-aKkNWadpfCiMylOnv6w,12748
@@ -43,9 +37,9 @@ abstract_webtools/managers/soupManager/__init__.py,sha256=mqfXfqM9sWlYpOkoXUqtBo
 abstract_webtools/managers/soupManager/asoueces.py,sha256=OaXqolZl0dI7b09NYwJ3Wnhuxf89ahZ1GjsOqy0GXfk,3506
 abstract_webtools/managers/soupManager/soupManager.py,sha256=U3_o189-OWoBRaSCe2sIkg-bHxBt2mKpYMyZd-nJjLQ,17201
 abstract_webtools/managers/urlManager/__init__.py,sha256=gaJCHeK91Z-eYsBnxgdhbIUten1-gbx-zqx70R6ag-Y,26
-abstract_webtools/managers/urlManager/urlManager.py,sha256=vCFuLADmv3h7icaaoAsImGqb_49VizPY_ZvMl-C7PYk,7756
-abstract_webtools/managers/videos/Heather brooke swallo from condom.mp4,sha256=h-bKFLAHt7pGLGu4EcMvSSox7BPRK0Nga3u813iMVKQ,8335544
-abstract_webtools-0.1.6.136.dist-info/METADATA,sha256=cWWwVrS22mwvKuIkiQuDDUiB07FW9chpXUZhvNi6lUg,7289
-abstract_webtools-0.1.6.136.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstract_webtools-0.1.6.136.dist-info/top_level.txt,sha256=2DMJ7RmjTcjCsa-uwAV0K6eXXlIIkFDEjBLg_uyCmCI,18
-abstract_webtools-0.1.6.136.dist-info/RECORD,,
+abstract_webtools/managers/urlManager/urlManager (Copy).py,sha256=vCFuLADmv3h7icaaoAsImGqb_49VizPY_ZvMl-C7PYk,7756
+abstract_webtools/managers/urlManager/urlManager.py,sha256=LG8WiEsf16vMzum48D5rmbRNK6VzYG4FyOTr2FJiOEc,9133
+abstract_webtools-0.1.6.138.dist-info/METADATA,sha256=wBxaIqQkImZwBOPVoOzJYc2UAp3jxtuL7y9SWULLiUY,7289
+abstract_webtools-0.1.6.138.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstract_webtools-0.1.6.138.dist-info/top_level.txt,sha256=2DMJ7RmjTcjCsa-uwAV0K6eXXlIIkFDEjBLg_uyCmCI,18
+abstract_webtools-0.1.6.138.dist-info/RECORD,,