abstract-webtools 0.1.4.54__py3-none-any.whl → 0.1.4.56__py3-none-any.whl

abstract_webtools/abstract_webtools.py

@@ -388,7 +388,7 @@ class MySocketClient():
     def get_instance(ip_address='local_host',port=22,domain_name="example.com"):
         if MySocketClientSingleton._instance is None:
             MySocketClientSingleton._instance = MySocketClient(ip_address=ip_address,port=port,domain_name=domain_name)
-        elif MySocketClientSingleton._instance.ip_address != ip_address or MySocketClientSingleton._instance.port != port or URLManagerSingleton._instance.domain_name != domain_name:
+        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
 def safe_json_loads(data):
@@ -402,13 +402,13 @@ def convert_to_json(obj):
     if isinstance(obj, str):
         return safe_json_loads(obj)
     return None
-class URLManager:
+class UrlManager:
     def __init__(self, url=None, session=requests):
         if url==None:
             url='www.example.com'
         self.url = url
         self.session = session
-        # These methods seem essential for setting up the URLManager object.
+        # These methods seem essential for setting up the UrlManager object.
         self.clean_urls = self.clean_url()
         self.correct_url = self.get_correct_url()
         self.url_to_pieces()
@@ -482,7 +482,7 @@ class URLManager:
                 print(e)
         return None
     def update_url(self,url):
-        # These methods seem essential for setting up the URLManager object.
+        # These methods seem essential for setting up the UrlManager object.
         self.url = url
         self.clean_urls = self.clean_url()
         self.correct_url = self.get_correct_url()
@@ -556,15 +556,15 @@ class URLManager:
                 r'^(?:https?:)?//', base):
             return None
         return urllib.parse.urljoin(base, path)
-class URLManagerSingleton:
+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
+        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
 class SafeRequest:
     def __init__(self,
                  url=None,
@@ -590,7 +590,7 @@ class SafeRequest:
                  max_retries=None,
                  request_wait_limit=None):
         if url_manager == None:
-            url_manager = URLManager(url=url)
+            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)
@@ -798,17 +798,17 @@ class SafeRequestSingleton:
     @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)
+            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)
+            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=None,source_code=None,url_manager=None,request_manager=None, parse_type="html.parser"):
         self.soup=[]
         self.url=url
         if url_manager == None:
-            url_manager=URLManager(url=self.url)
-        if self.url != None and url_manager != None and url_manager.url != URLManager(url=url).url:
+            url_manager=UrlManager(url=self.url)
+        if self.url != None and url_manager != None and url_manager.url != UrlManager(url=url).url:
             url_manager.update_url(url=self.url)
         self.url_manager= url_manager
         self.url=self.url_manager.url
@@ -1228,7 +1228,7 @@ class LinkManager:
     def __init__(self,url="https://example.com",source_code=None,url_manager=None,request_manager=None,soup_manager=None,image_link_tags='img',img_link_attrs='src',link_tags='a',link_attrs='href',strict_order_tags=False,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=url
         if url_manager==None:
-            url_manager=URLManager(url=url)
+            url_manager=UrlManager(url=url)
         self.url_manager= url_manager
         self.url=self.url_manager.url
         if request_manager==None:

abstract_webtools-0.1.4.56.dist-info/METADATA

@@ -0,0 +1,448 @@
+Metadata-Version: 2.1
+Name: abstract-webtools
+Version: 0.1.4.56
+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
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: abstract-webtools (>=0.1.0)
+Requires-Dist: abstract-utilities (>=0.2.0.0)
+Requires-Dist: PySimpleGUI (>=4.60.5)
+Requires-Dist: urllib3 (>=2.0.4)
+Requires-Dist: requests (>=2.31.0)
+
+# Abstract WebTools
+Provides utilities for inspecting and parsing web content, including React components and URL utilities, with enhanced capabilities for managing HTTP requests and TLS configurations.
+
+- **Features**:
+  - URL Validation: Ensures URL correctness and attempts different URL variations.
+  - HTTP Request Manager: Custom HTTP request handling, including tailored user agents and improved TLS security through a custom adapter.
+  - Source Code Acquisition: Retrieves the source code of specified websites.
+  - React Component Parsing: Extracts JavaScript and JSX source code from web pages.
+  - Comprehensive Link Extraction: Collects all internal links from a specified website.
+  - Web Content Analysis: Extracts and categorizes various web content components such as HTML elements, attribute values, attribute names, and class names.
+
+### abstract_webtools.py
+**Description:**  
+Abstract WebTools offers a suite of utilities designed for web content inspection and parsing. One of its standout features is its ability to analyze URLs, ensuring their validity and automatically attempting different URL variations to obtain correct website access. It boasts a custom HTTP request management system that tailors user-agent strings and employs a specialized TLS adapter for heightened security. The toolkit also provides robust capabilities for extracting source code, including detecting React components on web pages. Additionally, it offers functionalities for extracting all internal website links and performing in-depth web content analysis. This makes Abstract WebTools an indispensable tool for web developers, cybersecurity professionals, and digital analysts.
+![image](https://github.com/AbstractEndeavors/abstract_essentials/assets/57512254/0451d8ea-996f-4de5-9e6c-92a606aae4ef)
+
+- **Dependencies**:
+  - `requests`
+  - `ssl`
+  - `HTTPAdapter` from `requests.adapters`
+  - `PoolManager` from `urllib3.poolmanager`
+  - `ssl_` from `urllib3.util`
+  - `urlparse`, `urljoin` from `urllib.parse`
+  - `BeautifulSoup` from `bs4`
+
+
+# UrlManager
+
+The `UrlManager` is a Python class designed to handle and manipulate URLs. It provides methods for cleaning and normalizing URLs, determining the correct version of a URL, extracting URL components, and more. This class is particularly useful for web scraping, web crawling, or any application where URL management is essential.
+
+## Usage
+
+To use the `UrlManager` class, first import it into your Python script:
+
+```python
+from abstract_webtools import UrlManager
+```
+
+### Initializing a UrlManager Object
+
+You can create a `UrlManager` object by providing an initial URL and an optional `requests` session. If no URL is provided, it defaults to 'www.example.com':
+
+```python
+url_manager = UrlManager(url='https://www.example.com')
+```
+
+### URL Cleaning and Normalization
+
+The `clean_url` method takes a URL and returns a list of potential URL variations, including versions with and without 'www.', 'http://', and 'https://':
+
+```python
+cleaned_urls = url_manager.clean_url()
+```
+
+### Getting the Correct URL
+
+The `get_correct_url` method tries each possible URL variation with an HTTP request to determine the correct version of the URL:
+
+```python
+correct_url = url_manager.get_correct_url()
+```
+
+### Updating the URL
+
+You can update the URL associated with the `UrlManager` object using the `update_url` method:
+
+```python
+url_manager.update_url('https://www.example2.com')
+```
+
+### Extracting URL Components
+
+The `url_to_pieces` method extracts various components of the URL, such as protocol, domain name, path, and query:
+
+```python
+url_manager.url_to_pieces()
+print(url_manager.protocol)
+print(url_manager.domain_name)
+print(url_manager.path)
+print(url_manager.query)
+```
+
+### Additional Utility Methods
+
+- `get_domain_name(url)`: Returns the domain name (netloc) of a given URL.
+- `is_valid_url(url)`: Checks if a URL is valid.
+- `make_valid(href, url)`: Ensures a relative or incomplete URL is valid by joining it with a base URL.
+- `get_relative_href(url, href)`: Converts a relative URL to an absolute URL based on a base URL.
+
+## Compatibility Note
+
+The `get_domain` method is kept for compatibility but is inconsistent. Use it only for "webpage_url_domain." Similarly, `url_basename`, `base_url`, and `urljoin` methods are available for URL manipulation.
+
+## Example
+
+Here's a quick example of using the `UrlManager` class:
+
+```python
+from abstract_webtools import UrlManager
+
+url_manager = UrlManager(url='https://www.example.com')
+cleaned_urls = url_manager.clean_url()
+correct_url = url_manager.get_correct_url()
+url_manager.update_url('https://www.example2.com')
+
+print(f"Cleaned URLs: {cleaned_urls}")
+print(f"Correct URL: {correct_url}")
+```
+
+## Dependencies
+
+The `UrlManager` class relies on the `requests` library for making HTTP requests. Ensure you have the `requests` library installed in your Python environment.
+# SafeRequest
+
+The `SafeRequest` class is a versatile Python utility designed to handle HTTP requests with enhanced safety features. It integrates with other managers like `URLManager`, `NetworkManager`, and `UserAgentManager` to manage various aspects of the request, such as user-agent, SSL/TLS settings, proxies, headers, and more.
+
+## Usage
+
+To use the `SafeRequest` class, first import it into your Python script:
+
+```python
+from abstract_webtools import SafeRequest
+```
+
+### Initializing a SafeRequest Object
+
+You can create a `SafeRequest` object with various configuration options. By default, it uses sensible default values, but you can customize it as needed:
+
+```python
+safe_request = SafeRequest(url='https://www.example.com')
+```
+
+### Updating URL and URLManager
+
+You can update the URL associated with the `SafeRequest` object using the `update_url` method, which also updates the underlying `URLManager`:
+
+```python
+safe_request.update_url('https://www.example2.com')
+```
+
+You can also update the `URLManager` directly:
+
+```python
+from url_manager import URLManager
+
+url_manager = URLManager(url='https://www.example3.com')
+safe_request.update_url_manager(url_manager)
+```
+
+### Making HTTP Requests
+
+The `SafeRequest` class handles making HTTP requests using the `try_request` method. It handles retries, timeouts, and rate limiting:
+
+```python
+response = safe_request.try_request()
+if response:
+    # Process the response here
+```
+
+### Accessing Response Data
+
+You can access the response data in various formats:
+
+- `safe_request.source_code`: HTML source code as a string.
+- `safe_request.source_code_bytes`: HTML source code as bytes.
+- `safe_request.source_code_json`: JSON data from the response (if the content type is JSON).
+- `safe_request.react_source_code`: JavaScript and JSX source code extracted from `<script>` tags.
+
+### Customizing Request Configuration
+
+The `SafeRequest` class provides several options for customizing the request, such as headers, user-agent, proxies, SSL/TLS settings, and more. These can be set during initialization or updated later.
+
+### Handling Rate Limiting
+
+The class can handle rate limiting scenarios by implementing rate limiters and waiting between requests.
+
+### Error Handling
+
+The `SafeRequest` class handles various request-related exceptions and provides error messages for easier debugging.
+
+## Dependencies
+
+The `SafeRequest` class relies on the `requests` library for making HTTP requests. Ensure you have the `requests` library installed in your Python environment:
+
+```bash
+pip install requests
+```
+
+## Example
+
+Here's a quick example of using the `SafeRequest` class:
+
+```python
+from abstract_webtools import SafeRequest
+
+safe_request = SafeRequest(url='https://www.example.com')
+response = safe_request.try_request()
+if response:
+    print(f"Response status code: {response.status_code}")
+    print(f"HTML source code: {safe_request.source_code}")
+```
+
+# SoupManager
+
+The `SoupManager` class is a Python utility designed to simplify web scraping by providing easy access to the BeautifulSoup library. It allows you to parse and manipulate HTML or XML source code from a URL or provided source code.
+
+## Usage
+
+To use the `SoupManager` class, first import it into your Python script:
+
+```python
+from abstract_webtools import SoupManager
+```
+
+### Initializing a SoupManager Object
+
+You can create a `SoupManager` object with various configuration options. By default, it uses sensible default values, but you can customize it as needed:
+
+```python
+soup_manager = SoupManager(url='https://www.example.com')
+```
+
+### Updating URL and Request Manager
+
+You can update the URL associated with the `SoupManager` object using the `update_url` method, which also updates the underlying `URLManager` and `SafeRequest`:
+
+```python
+soup_manager.update_url('https://www.example2.com')
+```
+
+You can also update the source code directly:
+
+```python
+source_code = '<html>...</html>'
+soup_manager.update_source_code(source_code)
+```
+
+### Accessing and Parsing HTML
+
+The `SoupManager` class provides easy access to the BeautifulSoup object, allowing you to search, extract, and manipulate HTML elements easily. You can use methods like `find_all`, `get_class`, `has_attributes`, and more to work with the HTML content.
+
+```python
+elements = soup_manager.find_all(tag='a')
+```
+
+### Extracting Links
+
+The class also includes methods for extracting all website links from the HTML source code:
+
+```python
+all_links = soup_manager.all_links
+```
+
+### Extracting Meta Tags
+
+You can extract meta tags from the HTML source code using the `meta_tags` property:
+
+```python
+meta_tags = soup_manager.meta_tags
+```
+
+### Customizing Parsing
+
+You can customize the parsing behavior by specifying the parser type during initialization or updating it:
+
+```python
+soup_manager.update_parse_type('lxml')
+```
+
+## Dependencies
+
+The `SoupManager` class relies on the `BeautifulSoup` library for parsing HTML or XML. Ensure you have the `beautifulsoup4` library installed in your Python environment:
+
+```bash
+pip install beautifulsoup4
+```
+
+## Example
+
+Here's a quick example of using the `SoupManager` class:
+
+```python
+from abstract_webtools import SoupManager
+
+soup_manager = SoupManager(url='https://www.example.com')
+all_links = soup_manager.all_links
+print(f"All Links: {all_links}")
+```
+# LinkManager
+
+The `LinkManager` class is a Python utility designed to simplify the extraction and management of links (URLs) and associated data from HTML source code. It leverages other classes like `URLManager`, `SafeRequest`, and `SoupManager` to facilitate link extraction and manipulation.
+
+## Usage
+
+To use the `LinkManager` class, first import it into your Python script:
+
+```python
+from abstract_webtools import LinkManager
+```
+
+### Initializing a LinkManager Object
+
+You can create a `LinkManager` object with various configuration options. By default, it uses sensible default values, but you can customize it as needed:
+
+```python
+link_manager = LinkManager(url='https://www.example.com')
+```
+
+### Updating URL and Request Manager
+
+You can update the URL associated with the `LinkManager` object using the `update_url` method, which also updates the underlying `URLManager`, `SafeRequest`, and `SoupManager`:
+
+```python
+link_manager.update_url('https://www.example2.com')
+```
+
+### Accessing Extracted Links
+
+The `LinkManager` class provides easy access to extracted links and associated data:
+
+```python
+all_links = link_manager.all_desired_links
+```
+
+### Customizing Link Extraction
+
+You can customize the link extraction behavior by specifying various parameters during initialization or updating them:
+
+```python
+link_manager.update_desired(
+    img_attr_value_desired=['thumbnail', 'image'],
+    img_attr_value_undesired=['icon'],
+    link_attr_value_desired=['blog', 'article'],
+    link_attr_value_undesired=['archive'],
+    image_link_tags='img',
+    img_link_attrs='src',
+    link_tags='a',
+    link_attrs='href',
+    strict_order_tags=True,
+    associated_data_attr=['data-title', 'alt', 'title'],
+    get_img=['data-title', 'alt', 'title']
+)
+```
+
+## Dependencies
+
+The `LinkManager` class relies on other classes within the `abstract_webtools` module, such as `URLManager`, `SafeRequest`, and `SoupManager`. Ensure you have these classes and their dependencies correctly set up in your Python environment.
+
+## Example
+
+Here's a quick example of using the `LinkManager` class:
+
+```python
+from abstract_webtools import LinkManager
+
+link_manager = LinkManager(url='https://www.example.com')
+all_links = link_manager.all_desired_links
+print(f"All Links: {all_links}")
+```
+##Overall Usecases
+```python
+from abstract_webtools import URLManager, SafeRequest, SoupManager, LinkManager, VideoDownloader
+
+# --- URLManager: Manages and manipulates URLs for web scraping/crawling ---
+url = "example.com"
+url_manager = URLManager(url=url)
+
+# --- SafeRequest: Safely handles HTTP requests by managing user-agent, SSL/TLS, proxies, headers, etc. ---
+request_manager = SafeRequest(
+    url_manager=url_manager,
+    proxies={'8.219.195.47', '8.219.197.111'},
+    timeout=(3.05, 70)
+)
+
+# --- SoupManager: Simplifies web scraping with easy access to BeautifulSoup ---
+soup_manager = SoupManager(
+    url_manager=url_manager,
+    request_manager=request_manager
+)
+
+# --- LinkManager: Extracts and manages links and associated data from HTML source code ---
+link_manager = LinkManager(
+    url_manager=url_manager,
+    soup_manager=soup_manager,
+    link_attr_value_desired=['/view_video.php?viewkey='],
+    link_attr_value_undesired=['phantomjs']
+)
+
+# Download videos from provided links (list or string)
+video_manager = VideoDownloader(link=link_manager.all_desired_links).download()
+
+# Use them individually, with default dependencies for basic inputs:
+standalone_soup = SoupManager(url=url).soup
+standalone_links = LinkManager(url=url).all_desired_links
+
+# Updating methods for manager classes
+url_1 = 'thedailydialectics.com'
+print(f"updating URL to {url_1}")
+url_manager.update_url(url=url_1)
+request_manager.update_url(url=url_1)
+soup_manager.update_url(url=url_1)
+link_manager.update_url(url=url_1)
+
+# Updating URL manager references
+request_manager.update_url_manager(url_manager=url_manager)
+soup_manager.update_url_manager(url_manager=url_manager)
+link_manager.update_url_manager(url_manager=url_manager)
+
+# Updating source code for managers
+source_code_bytes = request_manager.source_code_bytes
+soup_manager.update_source_code(source_code=source_code_bytes)
+link_manager.update_source_code(source_code=source_code_bytes)
+```
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+#### Module Information
+-**Author**: putkoff
+-**Author Email**: partners@abstractendeavors.com
+-**Github**: https://github.com/AbstractEndeavors/abstract_essentials/tree/main/abstract_webtools
+-**PYPI**: https://pypi.org/project/abstract-webtools
+-**Part of**: abstract_essentials
+-**Date**: 10/10/2023
+-**Version**: 0.1.4.54
+---
+

{abstract_webtools-0.1.4.54.dist-info → abstract_webtools-0.1.4.56.dist-info}/RECORD

@@ -1,6 +1,6 @@
 abstract_webtools/__init__.py,sha256=2SWEfdPDHqqjUYsOQYlaOHF644ZYcO160nWKiAjga4w,34
 abstract_webtools/abstract_crawler.py,sha256=e8jVVv1_EB8poqlrdQaJ19z9Z0t8un5uc-DKnj1Ud5s,8002
-abstract_webtools/abstract_webtools.py,sha256=DLaVE-95qD6ItjNQ9-2E1h2qNcS_BGk2wCjVIGhso-o,76215
+abstract_webtools/abstract_webtools.py,sha256=ob9IjHg4xVcgIQQCeDGBqVmu8OCSRhXUSR3ljORDgi0,76215
 abstract_webtools/abstract_webtools2.py,sha256=dlhhgmUTaN_NgkT6GcJMVBLuXjmW38gAOeCrKxYqytk,30685
 abstract_webtools/big_user_agent_list.py,sha256=2Jzlg8rzEiwqFO0yaC8yGmGXQGZ_RWaHr3Apm6Gn1Yw,113552
 abstract_webtools/dfgdsf.py,sha256=T1pj-ne_qVfaAdu1MIdtW3q3UZqNP78Kt0OMhz4Musk,1355
@@ -10,8 +10,8 @@ abstract_webtools/sou.py,sha256=8HjmcpXJFi_kC2O-SVGebUIFY5I5B9bPP9L8BAiWhfk,4526
 abstract_webtools/soup.py,sha256=i9Z2EL8dufbzZGP_mrJom1DCQPUOfgfVlSbiHiPnCGo,4793
 abstract_webtools/test_var.py,sha256=EnxfhiLqNaG9MIHPyIbobufRzo4z1p0UIm8ArZybeRU,72
 abstract_webtools/vido_test.py,sha256=wP0YGj-dWBh76g7xpvC88nOtqfeTp2hdQ-mp4ywjjXg,147
-abstract_webtools-0.1.4.54.dist-info/LICENSE,sha256=g3WEJFiVS27HyCGRTwKSsMLyciMaGFdWcZGOe1QalZk,3877
-abstract_webtools-0.1.4.54.dist-info/METADATA,sha256=5fG4uH46i7pF9sCB7mFrCvs_TFTSrvYZuYHKOIlDpxA,8963
-abstract_webtools-0.1.4.54.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-abstract_webtools-0.1.4.54.dist-info/top_level.txt,sha256=2DMJ7RmjTcjCsa-uwAV0K6eXXlIIkFDEjBLg_uyCmCI,18
-abstract_webtools-0.1.4.54.dist-info/RECORD,,
+abstract_webtools-0.1.4.56.dist-info/LICENSE,sha256=g3WEJFiVS27HyCGRTwKSsMLyciMaGFdWcZGOe1QalZk,3877
+abstract_webtools-0.1.4.56.dist-info/METADATA,sha256=3R9juuedqawW4j8vITEc1ZXN_soHsp_q0wEEnF-Isqc,15908
+abstract_webtools-0.1.4.56.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+abstract_webtools-0.1.4.56.dist-info/top_level.txt,sha256=2DMJ7RmjTcjCsa-uwAV0K6eXXlIIkFDEjBLg_uyCmCI,18
+abstract_webtools-0.1.4.56.dist-info/RECORD,,

abstract_webtools-0.1.4.54.dist-info/METADATA

@@ -1,206 +0,0 @@
-Metadata-Version: 2.1
-Name: abstract-webtools
-Version: 0.1.4.54
-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
-Author-email: partners@abstractendeavors.com
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: abstract-webtools (>=0.1.0)
-Requires-Dist: abstract-utilities (>=0.2.0.0)
-Requires-Dist: PySimpleGUI (>=4.60.5)
-Requires-Dist: urllib3 (>=2.0.4)
-Requires-Dist: requests (>=2.31.0)
-
-#Abstract Webtools for parsing web content.
-
-
-**Module:** `abstract_webtools`  
-**Package:** `abstract_essentials`  
-**GitHub Repository:** [abstract_essentials](https://github.com/AbstractEndeavors/abstract_essentials/tree/main/abstract_webtools)  
-**Contact Email:** [partners@abstractendeavors.com](mailto:partners@abstractendeavors.com)  
-**Date:** 08/27/2023  
-**Version:** 0.0.0.1  
-
-
-## Installation
-
-You can install the package via pip:
-
-```bash
-pip install abstract_webtools
-```
-## Description
-
-The `abstract_webtools` module, part of the `abstract_essentials` package, provides various utilities and functionalities for web scraping and web request handling. This includes functions to retrieve and check the status of URLs, clean and format URLs, fetch source code with custom user agents, and more.
-
-## Classes
-
-1. **TLSAdapter(HTTPAdapter)**  
-   A custom HTTPAdapter class that configures TLS/SSL options and ciphers.
-
-## Dependencies
-
-This module relies on the following external libraries:
-
-- `requests`
-- `ssl`
-- `urllib`
-- `BeautifulSoup`
-
-## Usage
-
-### Get Status Code
-
-The `get_status` function fetches the status code of the URL.
-
-```python
-from abstract_webtools import clean_url
-
-urls = clean_url('https://example.com')
-print(urls)  # Output: ['https://example.com', 'http://example.com']
-tps://example.com'
-```
-
-### Try Request
-
-The `try_request` function makes HTTP requests to a URL and returns the response if successful.
-
-```python
-from abstract_webtools import try_request
-
-response = try_request('https://www.example.com')
-print(response)  # Output: <Response [200]>
-```
-
-### Is Valid URL
-
-The `is_valid` function checks whether a given URL is valid.
-
-```python
-from abstract_webtools import is_valid
-
-valid = is_valid('https://www.example.com')
-print(valid)  # Output: True
-```
-
-### Get Source Code
-
-The `get_Source_code` function fetches the source code of a URL with a custom user-agent.
-
-```python
-from abstract_webtools import get_Source_code
-
-source_code = get_Source_code('https://www.example.com')
-print(source_code)  # Output: HTML source code of the URL
-```
-
-### Parse React Source
-
-The `parse_react_source` function fetches the source code of a URL and extracts JavaScript and JSX source code (React components).
-
-```python
-from abstract_webtools import parse_react_source
-
-react_code = parse_react_source('https://www.example.com')
-print(react_code)  # Output: List of JavaScript and JSX source code found in <script> tags
-```
-
-### Get All Website Links
-
-The `get_all_website_links` function returns all URLs found on a specified URL that belong to the same website.
-
-```python
-from abstract_webtools import get_all_website_links
-
-links = get_all_website_links('https://www.example.com')
-print(links)  # Output: List of URLs belonging to the same website as the specified URL
-```
-
-### Parse All
-
-The `parse_all` function fetches the source code of a URL and extracts information about HTML elements, attribute values, attribute names, and class names.
-
-```python
-from abstract_webtools import parse_all
-
-HTML_components = parse_all('https://www.example.com')
-print(HTML_components["element_types"])       # Output: List of HTML element types
-print(HTML_components["attribute_values"])    # Output: List of attribute values
-print(HTML_components["attribute_names"])     # Output: List of attribute names
-print(HTML_components["class_names"])         # Output: List of class names
-```
-
-### Extract Elements
-
-The `extract_elements` function fetches the source code of a URL and extracts portions of the source code based on provided filters.
-
-```python
-from abstract_webtools import extract_elements
-
-elements = extract_elements('https://www.example.com', element_type='div', attribute_name='class', class_name='container')
-print(elements)  # Output: List of HTML elements that match the provided filters
-```
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-```
-
-This project is licensed under the MIT License
-
-MIT License
-
-The MIT License was first developed at the Massachusetts Institute of Technology (MIT) in the late 1980s. The exact origins MIT license are bit of mystery. Like the Apache 2.0, and BSD family of licenses the MIT License is a permissive software license that places few restrictions of reuse. Users of software using an MIT License are permitted to use, copy, modify, merge publish, distribute, sublicense and sell copies of the software. Some notable projects use the MIT License including Ruby on Rails, and the X Windows System.
-MIT License Conditions
-The MIT License is relatively simple and short. Below is the text of the MIT License from the Open Software Initiative.
-Begin license text.
-
-Copyright <YEAR> <COPYRIGHT HOLDER>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-End license text.
-Using MIT Licensed Code
-
- 
-
-The basic conditions of using the MIT License are:
-
-1. The original copyright notice
-
-2. A copy of the license itself
-
-are including in all copies or any substantial portions of the software.
-MIT License Compatibility
-
-The MIT License is highly compatible with other permissive licenses. Including the BSD family of licenses. It is generally compatible with  GNU GPL group of licenses. However if you distribute the code that contains or is derivative of GNU GPL code the final project must of GPL compliant. In other words any source code must of publicly available. 
-MIT License, Patents
-
-The MIT License was developed before patenting software was a common practice in the U.S. It therefore does not contain an express patent license. The broad nature of the license in general, is considered by some to encompass an implicit waiver of patent rights. If you are concerned about patent rights, the Apache 2.0 license contains an explicit contributor's patent license.
-MIT No Attribution License (MIT-0)
-
-The MIT No Attribution License is a Public Domain equivalent license it is similar to the  BSD Free license. 
-
- 
-
-Copyright <YEAR><COPYRIGHT HOLDER>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-```
-
-For additional details on usage and documentation of functions, refer to their respective docstrings in the module.