pyproxytools 0.3.2__py3-none-any.whl

benchmark/benchmark.py

@@ -0,0 +1,165 @@
+"""
+This module provides a set of functions to benchmark the performance of a proxy server
+by comparing the response times for HTTP requests sent with and without the use of a proxy.
+"""
+
+import time
+import argparse
+import sys
+import os
+from datetime import datetime
+import pandas as pd
+from utils.req import send_request_with_proxy, send_request_without_proxy
+from utils.html import create_combined_html_report
+
+
+def benchmark(url: str, proxy: str, num_requests: int) -> tuple:
+    """
+    Benchmarks the performance of sending requests to the specified$
+    URL with and without using a proxy. It sends multiple requests and
+    records the time taken for each.
+
+    Args:
+        url (str): The URL to benchmark.
+        proxy (str): The proxy URL to use for the benchmark.
+        num_requests (int): The number of requests to send.
+
+    Returns:
+        tuple: A tuple containing:
+            - A dictionary with statistics (average, min, max) for requests without and with proxy.
+            - A pandas DataFrame containing the times for each request without and with proxy.
+    """
+    times_without_proxy = []
+    times_with_proxy = []
+
+    print(f"Sending requests without proxy for {url}...")
+    for i in range(num_requests):
+        times_without_proxy.append(send_request_without_proxy(url))
+        sys.stdout.write(f"\rRequests sent without proxy: {i + 1}/{num_requests}")
+        sys.stdout.flush()
+        time.sleep(0.1)
+
+    print(f"\nSending requests with proxy for {url}...")
+    for i in range(num_requests):
+        times_with_proxy.append(send_request_with_proxy(url, proxy))
+        sys.stdout.write(f"\rRequests sent with proxy: {i + 1}/{num_requests}")
+        sys.stdout.flush()
+        time.sleep(0.1)
+
+    print("\n")
+
+    stats = {
+        "avg_without_proxy": sum(times_without_proxy) / len(times_without_proxy),
+        "min_without_proxy": min(times_without_proxy),
+        "max_without_proxy": max(times_without_proxy),
+        "avg_with_proxy": sum(times_with_proxy) / len(times_with_proxy),
+        "min_with_proxy": min(times_with_proxy),
+        "max_with_proxy": max(times_with_proxy),
+    }
+
+    results = pd.DataFrame(
+        {
+            "Request Number": range(1, num_requests + 1),
+            "Without Proxy": times_without_proxy,
+            "With Proxy": times_with_proxy,
+        }
+    )
+
+    return stats, results
+
+
+def main() -> None:
+    """
+    Main function to parse command-line arguments, run benchmarks, and generate the report.
+    It either benchmarks a single URL or a list of URLs from a file.
+
+    Returns:
+        None
+    """
+    parser = argparse.ArgumentParser(description="Proxy performance benchmark.")
+    parser.add_argument(
+        "--proxy-url",
+        type=str,
+        default="http://localhost:8080",
+        help="The proxy URL to use",
+    )
+    parser.add_argument(
+        "--target-url",
+        type=str,
+        help="A single URL to test (e.g., http://example.com)",
+    )
+    parser.add_argument(
+        "--target-file",
+        type=str,
+        help="A file containing a list of URLs to test",
+    )
+    parser.add_argument(
+        "--num-requests",
+        type=int,
+        default=10,
+        help="Number of requests to send (default: 10)",
+    )
+    parser.add_argument(
+        "--output-dir", type=str, default="benchmark/outputs", help="Output directory"
+    )
+    args = parser.parse_args()
+
+    if not args.target_url and not args.target_file:
+        print("Error: you must provide either --target-url or --target-file.")
+        sys.exit(1)
+
+    if not os.path.exists(args.output_dir):
+        os.makedirs(args.output_dir)
+
+    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    all_results = {}
+
+    if args.target_file:
+        if not os.path.exists(args.target_file):
+            print(f"Error: the file {args.target_file} does not exist.")
+            sys.exit(1)
+
+        with open(args.target_file, "r", encoding="utf-8") as f:
+            urls = [line.strip() for line in f if line.strip()]
+
+        for url in urls:
+            print(f"\nBenchmarking for {url}")
+            stats, results = benchmark(url, args.proxy_url, args.num_requests)
+            all_results[url] = (stats, results)
+    else:
+        stats, results = benchmark(args.target_url, args.proxy_url, args.num_requests)
+        all_results[args.target_url] = (stats, results)
+
+    avg_without_proxy_list = []
+    avg_with_proxy_list = []
+
+    for stats, _ in all_results.values():
+        avg_without_proxy_list.append(stats["avg_without_proxy"])
+        avg_with_proxy_list.append(stats["avg_with_proxy"])
+
+    global_avg_without_proxy = sum(avg_without_proxy_list) / len(avg_without_proxy_list)
+    global_avg_with_proxy = sum(avg_with_proxy_list) / len(avg_with_proxy_list)
+
+    percentage_change = (
+        (global_avg_with_proxy - global_avg_without_proxy) / global_avg_without_proxy
+    ) * 100
+
+    print(f"Global average without proxy: {global_avg_without_proxy:.6f} seconds")
+    print(f"Global average with proxy: {global_avg_with_proxy:.6f} seconds")
+    print(
+        f"Impact: {'Improvement' if percentage_change < 0 else 'Slowdown'} of "
+        f"{abs(percentage_change):.2f}%"
+    )
+
+    create_combined_html_report(
+        all_results,
+        global_avg_without_proxy,
+        global_avg_with_proxy,
+        percentage_change,
+        args.output_dir,
+        timestamp,
+    )
+
+
+if __name__ == "__main__":
+    main()

benchmark/utils/html.py

@@ -0,0 +1,179 @@
+"""
+This module provides functions for generating HTML reports to visualize
+benchmark results comparing performance with and without a proxy.
+"""
+
+import os
+import plotly.graph_objects as go
+
+TEMPLATE_PATH = "benchmark/templates/report_template.html"
+
+
+def generate_combined_table(all_results: dict) -> str:
+    """
+    Generates a single HTML table combining statistics for all
+    URLs with sub-columns for avg, min, and max.
+
+    Args:
+        all_results (dict): A dictionary containing the results for each URL.
+
+    Returns:
+        str: The HTML table as a string.
+    """
+    table_html = """
+    <div class="summary">
+        <h2>Benchmark Results Summary</h2>
+        <table>
+            <thead>
+                <tr>
+                    <th>URL</th>
+                    <th colspan="3">Without Proxy</th>
+                    <th colspan="3">With Proxy</th>
+                </tr>
+                <tr>
+                    <th></th>
+                    <th>Avg (s)</th>
+                    <th>Min (s)</th>
+                    <th>Max (s)</th>
+                    <th>Avg (s)</th>
+                    <th>Min (s)</th>
+                    <th>Max (s)</th>
+                </tr>
+            </thead>
+            <tbody>
+    """
+
+    for url, (stats, _) in all_results.items():
+        table_html += f"""
+            <tr>
+                <td>{url}</td>
+                <td>{stats['avg_without_proxy']:.5f}</td>
+                <td>{stats['min_without_proxy']:.5f}</td>
+                <td>{stats['max_without_proxy']:.5f}</td>
+                <td>{stats['avg_with_proxy']:.5f}</td>
+                <td>{stats['min_with_proxy']:.5f}</td>
+                <td>{stats['max_with_proxy']:.5f}</td>
+            </tr>
+        """
+
+    table_html += """
+            </tbody>
+        </table>
+    </div>
+    <hr>
+    """
+
+    return table_html
+
+
+def prepare_filenames(output_dir: str, timestamp: str) -> dict:
+    """
+    Prepares the filenames for the report and plotly files.
+
+    Args:
+        output_dir (str): The directory to save the report in.
+        timestamp (str): The timestamp to use in filenames.
+
+    Returns:
+        dict: A dictionary containing the plotly and html file paths.
+    """
+    output_dir = os.path.normpath(output_dir)
+
+    plotly_filename = f"benchmark_combined_interactive_{timestamp}.html"
+    html_filename = f"benchmark_combined_report_{timestamp}.html"
+
+    plotly_filepath = os.path.join(output_dir, plotly_filename)
+    html_filepath = os.path.join(output_dir, html_filename)
+
+    return {"plotly": plotly_filepath, "html": html_filepath}
+
+
+def render_template(template_path: str, context: dict) -> str:
+    """
+    Renders an HTML template by replacing placeholders with provided context.
+
+    Args:
+        template_path (str): Path to the HTML template.
+        context (dict): A dictionary with keys matching placeholders.
+
+    Returns:
+        str: The rendered HTML content.
+    """
+    with open(template_path, "r", encoding="utf-8") as f:
+        template = f.read()
+    return template.format(**context)
+
+
+def create_combined_html_report(
+    all_results: dict,
+    avg_without_proxy: float,
+    avg_with_proxy: float,
+    percentage_change: float,
+    output_dir: str,
+    timestamp: str,
+) -> None:
+    """
+    Generates an HTML report with the benchmark results, including graphs and statistics.
+    Saves the report to the specified output directory.
+
+    Args:
+        all_results (dict): A dictionary containing the results for each URL.
+        avg_without_proxy (float): The average time for requests without a proxy.
+        avg_with_proxy (float): The average time for requests with a proxy.
+        percentage_change (float): The percentage change in performance
+                    between requests with and without a proxy.
+        output_dir (str): The directory to save the report in.
+        timestamp (str): The timestamp to use in filenames.
+
+    Returns:
+        None
+    """
+    fig = go.Figure()
+
+    filenames = prepare_filenames(output_dir, timestamp)
+
+    for url, (_, results) in all_results.items():
+        fig.add_trace(
+            go.Scatter(
+                x=results["Request Number"],
+                y=results["Without Proxy"],
+                mode="lines+markers",
+                name=f"Without Proxy - {url}",
+            )
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=results["Request Number"],
+                y=results["With Proxy"],
+                mode="lines+markers",
+                name=f"With Proxy - {url}",
+            )
+        )
+
+    fig.update_layout(
+        title="Response Time per Request (All URLs)",
+        xaxis_title="Request Number",
+        yaxis_title="Response Time (seconds)",
+    )
+
+    fig.write_html(filenames["plotly"])
+
+    html_sections = generate_combined_table(all_results)
+
+    context = {
+        "avg_without_proxy": f"{avg_without_proxy:.6f} seconds",
+        "avg_with_proxy": f"{avg_with_proxy:.6f} seconds",
+        "impact": (
+            f"{'Improvement' if percentage_change < 0 else 'Slowdown'} "
+            f"of {abs(percentage_change):.2f}%"
+        ),
+        "html_sections": html_sections,
+        "plotly_filename": os.path.basename(filenames["plotly"]),
+    }
+
+    html_content = render_template(TEMPLATE_PATH, context)
+
+    with open(filenames["html"], "w", encoding="utf-8") as f:
+        f.write(html_content)
+
+    print(f"\nThe combined report has been generated at '{filenames['html']}'.")

benchmark/utils/req.py

@@ -0,0 +1,43 @@
+"""
+Module for sending HTTP GET requests with and without a proxy,
+and measuring the request completion time.
+"""
+
+import time
+import requests
+
+
+def send_request_without_proxy(url: str) -> float:
+    """
+    Sends an HTTP GET request to the provided URL without using a proxy,
+    and measures the time it takes to complete the request.
+
+    Args:
+        url (str): The URL to send the request to.
+
+    Returns:
+        float: The time taken to complete the request in seconds.
+    """
+    start_time = time.time()
+    requests.get(url, timeout=10)
+    end_time = time.time()
+    return end_time - start_time
+
+
+def send_request_with_proxy(url: str, proxy: str) -> float:
+    """
+    Sends an HTTP GET request to the provided URL using a proxy,
+    and measures the time it takes to complete the request.
+
+    Args:
+        url (str): The URL to send the request to.
+        proxy (str): The proxy URL to use for the request.
+
+    Returns:
+        float: The time taken to complete the request in seconds.
+    """
+    proxies = {"http": proxy, "https": proxy}
+    start_time = time.time()
+    requests.get(url, proxies=proxies, timeout=10)
+    end_time = time.time()
+    return end_time - start_time

pyproxy/__init__.py

@@ -0,0 +1,13 @@
+"""
+This module defines the version of the application. It contains a single constant
+that holds the current version number of the application.
+"""
+
+import os
+
+__version__ = "0.3.2"
+
+if os.path.isdir("pyproxy/monitoring"):
+    __slim__ = False
+else:
+    __slim__ = True

pyproxy/handlers/client.py

@@ -0,0 +1,126 @@
+"""
+pyproxy.handlers.client.py
+
+This module defines the ProxyHandlers class used by the proxy server to process
+HTTP and HTTPS client connections. It handles request forwarding, blocking, shortcut
+redirection, custom headers, and optional SSL inspection.
+"""
+
+import threading
+
+from pyproxy.handlers.http import HttpHandler
+from pyproxy.handlers.https import HttpsHandler
+
+
+class ProxyHandlers:
+    """
+    ProxyHandlers manages client connections for a proxy server, handling both HTTP
+    and HTTPS requests. It processes request forwarding, blocking, SSL inspection,
+    and custom headers based on configuration settings. This class is responsible
+    for dispatching the correct handler for HTTP or HTTPS requests and managing
+    connection-related operations.
+    """
+
+    def __init__(
+        self,
+        html_403,
+        logger_config,
+        filter_config,
+        ssl_config,
+        filter_queue,
+        filter_result_queue,
+        shortcuts_queue,
+        shortcuts_result_queue,
+        cancel_inspect_queue,
+        cancel_inspect_result_queue,
+        custom_header_queue,
+        custom_header_result_queue,
+        console_logger,
+        shortcuts,
+        custom_header,
+        active_connections,
+        proxy_enable,
+        proxy_host,
+        proxy_port,
+    ):
+        self.html_403 = html_403
+        self.logger_config = logger_config
+        self.filter_config = filter_config
+        self.ssl_config = ssl_config
+        self.filter_queue = filter_queue
+        self.filter_result_queue = filter_result_queue
+        self.shortcuts_queue = shortcuts_queue
+        self.shortcuts_result_queue = shortcuts_result_queue
+        self.cancel_inspect_queue = cancel_inspect_queue
+        self.cancel_inspect_result_queue = cancel_inspect_result_queue
+        self.custom_header_queue = custom_header_queue
+        self.custom_header_result_queue = custom_header_result_queue
+        self.console_logger = console_logger
+        self.config_shortcuts = shortcuts
+        self.config_custom_header = custom_header
+        self.proxy_enable = proxy_enable
+        self.proxy_host = proxy_host
+        self.proxy_port = proxy_port
+        self.active_connections = active_connections
+
+    def handle_client(self, client_socket):
+        """
+        Handles an incoming client connection by processing the request and forwarding
+        it to the appropriate handler based on whether the request is HTTP or HTTPS.
+
+        Args:
+            client_socket (socket): The socket object for the client connection.
+        """
+        request = client_socket.recv(4096)
+
+        if not request:
+            self.console_logger.debug("No request received, closing connection.")
+            client_socket.close()
+            self.active_connections.pop(threading.get_ident(), None)
+            return
+
+        first_line = request.decode(errors="ignore").split("\n")[0]
+
+        if first_line.startswith("CONNECT"):
+            client_https_handler = HttpsHandler(
+                html_403=self.html_403,
+                logger_config=self.logger_config,
+                filter_config=self.filter_config,
+                ssl_config=self.ssl_config,
+                filter_queue=self.filter_queue,
+                filter_result_queue=self.filter_result_queue,
+                shortcuts_queue=self.shortcuts_queue,
+                shortcuts_result_queue=self.shortcuts_result_queue,
+                cancel_inspect_queue=self.cancel_inspect_queue,
+                cancel_inspect_result_queue=self.cancel_inspect_result_queue,
+                custom_header_queue=self.custom_header_queue,
+                custom_header_result_queue=self.custom_header_result_queue,
+                console_logger=self.console_logger,
+                shortcuts=self.config_shortcuts,
+                custom_header=self.config_custom_header,
+                proxy_enable=self.proxy_enable,
+                proxy_host=self.proxy_host,
+                proxy_port=self.proxy_port,
+                active_connections=self.active_connections,
+            )
+            client_https_handler.handle_https_connection(client_socket, first_line)
+        else:
+            client_http_handler = HttpHandler(
+                html_403=self.html_403,
+                logger_config=self.logger_config,
+                filter_config=self.filter_config,
+                filter_queue=self.filter_queue,
+                filter_result_queue=self.filter_result_queue,
+                shortcuts_queue=self.shortcuts_queue,
+                shortcuts_result_queue=self.shortcuts_result_queue,
+                custom_header_queue=self.custom_header_queue,
+                custom_header_result_queue=self.custom_header_result_queue,
+                console_logger=self.console_logger,
+                shortcuts=self.config_shortcuts,
+                custom_header=self.config_custom_header,
+                proxy_enable=self.proxy_enable,
+                proxy_host=self.proxy_host,
+                proxy_port=self.proxy_port,
+                active_connections=self.active_connections,
+            )
+            client_http_handler.handle_http_request(client_socket, request)