changed readme and public apis

Author: rishiraj

README.md

@@ -1,99 +1,96 @@
 # FireRequests 🔥
 
-[![PyPI version](https://badge.fury.io/py/firerequests.svg)](https://badge.fury.io/py/firerequests)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![PyPI version](https://img.shields.io/pypi/v/firerequests.svg)](https://pypi.org/project/firerequests/)  
+[![License](https://img.shields.io/pypi/l/firerequests.svg)](https://github.com/rishiraj/firerequests/blob/main/LICENSE)  
+[![Python version](https://img.shields.io/pypi/pyversions/firerequests.svg)](https://pypi.org/project/firerequests/)
 
-FireRequests is a cutting-edge, high-performance asynchronous HTTP client library designed for blazing-fast file transfers. Leveraging advanced concurrency paradigms and innovative networking techniques, FireRequests achieves up to 5x real-world speed improvements over traditional synchronous methods.
+**FireRequests** is a high-performance, asynchronous HTTP client library for Python, engineered to accelerate your file transfers. By harnessing advanced concepts like semaphores, exponential backoff with jitter, concurrency, and fault tolerance, FireRequests can achieve up to a **5x real-world speedup** in file downloads and uploads compared to traditional synchronous methods.
 
-## Key Features
+## Features 🚀
 
-- **Asynchronous Architecture**: Utilizes `asyncio` for non-blocking I/O operations, maximizing throughput and minimizing latency.
-- **Concurrent Chunk Processing**: Implements parallel downloading and uploading of file chunks for optimal resource utilization.
-- **Adaptive Exponential Backoff**: Incorporates a sophisticated retry mechanism with jitter for robust error handling and network resilience.
-- **Semaphore-based Concurrency Control**: Employs fine-grained concurrency management to prevent resource exhaustion and ensure system stability.
-- **Progress Visualization**: Integrates `tqdm` for real-time progress tracking, enhancing user experience and operational visibility.
-- **Flexible API**: Supports both high-level convenience methods and low-level customization options for advanced use cases.
+- **Asynchronous I/O**: Non-blocking network and file operations using `asyncio`, `aiohttp`, and `aiofiles`, boosting throughput for I/O-bound tasks.
+- **Concurrent Transfers**: Uses `asyncio.Semaphore` to limit simultaneous tasks, optimizing performance by managing system resources effectively.
+- **Fault Tolerance**: Retries failed tasks with exponentially increasing wait times, adding random jitter to prevent network congestion.
+- **Chunked Processing**: Files are split into configurable chunks for parallel processing, significantly accelerating uploads/downloads.
+- **Compatibility**: Supports environments like Jupyter through `nest_asyncio`, enabling reusable `asyncio` loops for both batch and interactive Jupyter use.
 
-## Installation
+## Installation 📦
+
+Install FireRequests using pip:
 
 ```bash
 pip install firerequests
 ```
 
-## Usage Examples
+## Quick Start 🏁
 
-### High-Speed File Download
+Accelerate your downloads with just a few lines of code:
 
 ```python
 from firerequests import FireRequests
 
-fr = FireRequests()
-url = "https://example.com/large-file.iso"
-filename = "large-file.iso"
+url = "https://example.com/largefile.iso"
+filename = "largefile.iso"
 
-# Asynchronous download with optimized parameters
-fr.run_download(url, filename, max_files=10, chunk_size=2 * 1024 * 1024)
+fr = FireRequests()
+fr.download(url, filename)
 ```
 
-### Accelerated File Upload
+## Real-World Speed Test 🏎️
 
-```python
-from firerequests import FireRequests
+FireRequests delivers significant performance improvements over traditional download methods. Below is the result of a real-world speed test:
 
-fr = FireRequests()
-file_path = "large-file.iso"
-parts_urls = ["https://example.com/upload/part1", "https://example.com/upload/part2", ...]
+```plaintext
+Normal Download 🐌: 100%|██████████| 3.42G/3.42G [06:16<00:00, 9.08MB/s]
+Downloading on 🔥: 100%|██████████| 3.42G/3.42G [01:15<00:00, 45.2MB/s]
 
-# Parallel multi-part upload
-fr.run_upload(file_path, parts_urls, chunk_size=5 * 1024 * 1024, max_files=8)
+🐌 Download Time: 376.77 seconds
+🔥 Download Time: 75.75 seconds
 ```
 
-### Performance Comparison
+## Advanced Usage ⚙️
+
+### Downloading Files
 
 ```python
-fr = FireRequests()
-url = "https://mirror.example.com/large-dataset.zip"
-filename = "large-dataset.zip"
+from firerequests import FireRequests
 
-# Benchmark FireRequests against traditional methods
-fr.compare_speed(url, filename)
+url = "https://example.com/largefile.iso"
+filename = "largefile.iso"
+
+fr = FireRequests()
+fr.download(url, filename, max_files=10, chunk_size=2 * 1024 * 1024)
 ```
 
-## Advanced Usage
+- **`url`**: The URL of the file to download.
+- **`filename`**: The local filename to save the downloaded file.
+- **`max_files`**: The maximum number of concurrent chunk downloads.
+- **`chunk_size`**: The size of each chunk in bytes.
 
-### Custom Callback Integration
+### Uploading Files
 
 ```python
-import asyncio
 from firerequests import FireRequests
 
-async def progress_callback(bytes_transferred):
-    print(f"Transferred: {bytes_transferred / 1024 / 1024:.2f} MB")
+file_path = "largefile.iso"
+parts_urls = ["https://example.com/upload_part1", "https://example.com/upload_part2", ...]
 
 fr = FireRequests()
-url = "https://example.com/massive-file.tar.gz"
-filename = "massive-file.tar.gz"
-
-asyncio.run(fr.download_file(
-    url, filename, max_files=12, chunk_size=4 * 1024 * 1024,
-    callback=progress_callback
-))
+fr.upload(file_path, parts_urls, chunk_size=2 * 1024 * 1024, max_files=10)
 ```
 
-## Performance Metrics
-
-In real-world tests, FireRequests demonstrated exceptional performance gains:
-
-- **Traditional Download**: 376.77 seconds
-- **FireRequests Download**: 75.75 seconds
-- **Speed Improvement**: 4.98x faster
+### Comparing Download Speed
 
-These results showcase the significant efficiency enhancements achievable through FireRequests' advanced asynchronous architecture and optimized networking strategies.
+```python
+from firerequests import FireRequests
 
-## Contributing
+url = "https://example.com/largefile.iso"
+filename = "largefile.iso"
 
-We welcome contributions! Please see our [Contributing Guidelines](CONTRIBUTING.md) for more details.
+fr = FireRequests()
+fr.compare_speed(url, filename)
+```
 
-## License
+## License 📄
 
-FireRequests is released under the Apache License 2.0. See the [LICENSE](LICENSE) file for more details.
+This project is licensed under the Apache License 2.0 - see the [LICENSE](https://github.com/rishiraj/firerequests/blob/main/LICENSE) file for details.

firerequests/main.py

@@ -64,7 +64,7 @@ async def download_file(
                     session, url, filename, start, stop, headers, semaphore, parallel_failures, max_retries
                 ))
 
-            progress_bar = tqdm(total=file_size, unit="B", unit_scale=True, desc="Downloading")
+            progress_bar = tqdm(total=file_size, unit="B", unit_scale=True, desc="Downloading on 🔥")
             for chunk_result in asyncio.as_completed(tasks):
                 downloaded = await chunk_result
                 progress_bar.update(downloaded)
@@ -103,7 +103,7 @@ async def upload_file(
                     session, part_url, file_path, start, chunk_size, semaphore, parallel_failures, max_retries
                 ))
 
-            progress_bar = tqdm(total=file_size, unit="B", unit_scale=True, desc="Uploading")
+            progress_bar = tqdm(total=file_size, unit="B", unit_scale=True, desc="Uploading on 🔥")
             for chunk_result in asyncio.as_completed(tasks):
                 uploaded = await chunk_result
                 progress_bar.update(uploaded)
@@ -146,7 +146,7 @@ def upload(self, file_path: str, parts_urls: List[str], chunk_size: int, max_fil
     def normal_download(self, url: str, filename: str):
         response = requests.get(url, stream=True)
         total_size = int(response.headers.get('content-length', 0))
-        progress_bar = tqdm(total=total_size, unit="B", unit_scale=True, desc="Normal Download")
+        progress_bar = tqdm(total=total_size, unit="B", unit_scale=True, desc="Normal Download 🐌")
         with open(filename, 'wb') as f:
             for data in response.iter_content(1024):
                 progress_bar.update(len(data))
@@ -162,10 +162,10 @@ def compare_speed(self, url: str, filename: str):
 
         start_time = time.time()
         asyncio.run(self.download_file(url, filename, max_files=10, chunk_size=2 * 1024 * 1024))
-        fast_time = time.time() - start_time
+        fire_time = time.time() - start_time
 
-        print(f"\nNormal Download Time: {normal_time:.2f} seconds")
-        print(f"Fast Download Time: {fast_time:.2f} seconds\n")
+        print(f"\n🐌 Download Time: {normal_time:.2f} seconds")
+        print(f"🔥 Download Time: {fire_time:.2f} seconds\n")
 
 
 if __name__ == "__main__":