Ruff formatting

Author: 6C656C65

.dockerignore

@@ -19,7 +19,6 @@ benchmark/
 .gitignore
 .git
 .gitattributes
-.flake8
 .readthedocs.yaml
 CHANGELOG.md
 CONTRIBUTING.md

.github/workflows/main.yml

@@ -22,16 +22,13 @@ jobs:
           python-version: ${{ matrix.python-version }}
 
       - name: Install dependencies
-        run: pip install --no-cache-dir -U pip black flake8 bandit
+        run: pip install --no-cache-dir -U pip ruff
 
-      - name: Lint with flake8
-        run: flake8 pyproxy tests benchmark
+      - name: Lint and security check with Ruff
+        run: ruff check pyproxy tests benchmark
 
-      - name: Check with black
-        run: black --check pyproxy tests benchmark
-
-      - name: Check with bandit
-        run: bandit -r pyproxy tests benchmark
+      - name: Check code formatting with Ruff
+        run: ruff format --check pyproxy tests benchmark
 
   unittest:
     needs: code-scan

.pre-commit-config.yaml

@@ -1,20 +1,7 @@
 repos:
-  - repo: https://github.com/psf/black
-    rev: 25.9.0
-    hooks:
-      - id: black
-        language_version: python3.13
-
   - repo: https://github.com/charliermarsh/ruff-pre-commit
     rev: v0.14.0
     hooks:
       - id: ruff-check
         args: [--fix]
       - id: ruff-format
-
-  - repo: https://github.com/PyCQA/bandit
-    rev: 1.8.6
-    hooks:
-      - id: bandit
-        args: ["-r", "pyproxy", "tests", "benchmark"]
-        exclude: "setup.py"

CONTRIBUTING.md

@@ -19,9 +19,9 @@ Whether you're fixing bugs, writing tests, or improving documentation, all contr
 ## ✅ Development Guidelines
 
 - Follow [PEP8](https://peps.python.org/pep-0008/) coding style.
-- We use **flake8** to ensure code quality:
+- We use **Ruff** to ensure code quality:
   ```bash
-  flake8 pyproxy tests benchmark
+  ruff check
   ```
 - Tests are written using **unittest**. To run all tests:
   ```bash

benchmark/utils/html.py

@@ -47,12 +47,12 @@ def generate_combined_table(all_results: dict) -> str:
         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>
+                <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>
         """
 

pyproject.toml

@@ -17,6 +17,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Internet",
     "Topic :: Software Development :: Libraries",
     "Topic :: Software Development :: Libraries :: Python Modules",
@@ -44,10 +45,11 @@ exclude = [
     "build",
     "dist",
     "venv",
+    "setup.py",
 ]
 
 [tool.ruff.lint]
-select = ["E", "F", "W"]
+select = ["E", "F", "W", "S"]
 
 [tool.ruff.format]
 quote-style = "double"

pyproxy/handlers/http.py

@@ -62,9 +62,7 @@ def _get_modified_headers(self, url, request_text):
             new_headers = self.custom_header_result_queue.get(timeout=5)
             headers.update(new_headers)
         except Exception:
-            self.console_logger.warning(
-                "Timeout while getting custom headers for %s", url
-            )
+            self.console_logger.warning("Timeout while getting custom headers for %s", url)
         return headers
 
     def _rebuild_http_request(self, request_line, headers, body=""):
@@ -86,9 +84,7 @@ def _apply_shortcut(self, url: str) -> str | None:
             try:
                 return self.shortcuts_result_queue.get(timeout=5)
             except Exception:
-                self.console_logger.warning(
-                    "Timeout while getting shortcut for %s", url
-                )
+                self.console_logger.warning("Timeout while getting shortcut for %s", url)
         return None
 
     def _is_blocked(self, url: str) -> bool:
@@ -150,10 +146,7 @@ def handle_http_request(self, client_socket, request):
             shortcut_url = self._apply_shortcut(url)
             if shortcut_url:
                 response = (
-                    f"HTTP/1.1 302 Found\r\n"
-                    f"Location: {shortcut_url}\r\n"
-                    f"Content-Length: 0\r\n"
-                    "\r\n"
+                    f"HTTP/1.1 302 Found\r\nLocation: {shortcut_url}\r\nContent-Length: 0\r\n\r\n"
                 )
 
                 client_socket.sendall(response.encode())
@@ -170,16 +163,10 @@ def handle_http_request(self, client_socket, request):
             request_lines = request_text.split("\r\n")
             headers = self._get_modified_headers(url, request_text)
             request_line = request_lines[0]
-            body = (
-                request_text.split("\r\n\r\n", 1)[1]
-                if "\r\n\r\n" in request_text
-                else ""
-            )
+            body = request_text.split("\r\n\r\n", 1)[1] if "\r\n\r\n" in request_text else ""
             modified_request = self._rebuild_http_request(request_line, headers, body)
 
-            self.forward_request_to_server(
-                client_socket, modified_request, url, first_line
-            )
+            self.forward_request_to_server(client_socket, modified_request, url, first_line)
 
         else:
             self.forward_request_to_server(client_socket, request, url, first_line)
@@ -199,9 +186,7 @@ def forward_request_to_server(self, client_socket, request, url, first_line):
         else:
             parsed_url = urlparse(url)
             server_host = parsed_url.hostname
-            server_port = parsed_url.port or (
-                443 if parsed_url.scheme == "https" else 80
-            )
+            server_port = parsed_url.port or (443 if parsed_url.scheme == "https" else 80)
 
         try:
             ip_address = socket.gethostbyname(server_host)
@@ -233,17 +218,13 @@ def forward_request_to_server(self, client_socket, request, url, first_line):
                     response = server_socket.recv(4096)
                     if response:
                         client_socket.send(response)
-                        self.active_connections[thread_id]["bytes_received"] += len(
-                            response
-                        )
+                        self.active_connections[thread_id]["bytes_received"] += len(response)
                     else:
                         break
                 except socket.timeout:
                     break
         except (socket.timeout, socket.gaierror, ConnectionRefusedError, OSError) as e:
-            self.console_logger.error(
-                "Error connecting to the server %s : %s", server_host, e
-            )
+            self.console_logger.error("Error connecting to the server %s : %s", server_host, e)
             response = (
                 f"HTTP/1.1 502 Bad Gateway\r\n"
                 f"Content-Length: {len('Bad Gateway')} \r\n"

pyproxy/handlers/https.py

@@ -271,12 +271,8 @@ def handle_https_connection(self, client_socket, first_line):
 
                 tls_version = ssl_client_socket.version() or "unknown"
 
-                server_socket = self._establish_server_connection(
-                    server_host, server_port
-                )
-                ssl_server_socket = self._wrap_server_socket_with_ssl(
-                    server_socket, server_host
-                )
+                server_socket = self._establish_server_connection(server_host, server_port)
+                ssl_server_socket = self._wrap_server_socket_with_ssl(server_socket, server_host)
 
                 first_request, full_url, is_blocked = self._process_first_ssl_request(
                     ssl_client_socket, server_host, first_line
@@ -324,9 +320,7 @@ def handle_https_connection(self, client_socket, first_line):
 
         else:
             try:
-                server_socket = self._establish_server_connection(
-                    server_host, server_port
-                )
+                server_socket = self._establish_server_connection(server_host, server_port)
                 client_socket.sendall(b"HTTP/1.1 200 Connection Established\r\n\r\n")
 
                 client_ip = client_socket.getpeername()[0]
@@ -355,9 +349,7 @@ def handle_https_connection(self, client_socket, first_line):
                 ConnectionRefusedError,
                 OSError,
             ) as e:
-                self.console_logger.error(
-                    "Error connecting to the server %s: %s", server_host, e
-                )
+                self.console_logger.error("Error connecting to the server %s: %s", server_host, e)
                 response = (
                     f"HTTP/1.1 502 Bad Gateway\r\n"
                     f"Content-Length: {len('Bad Gateway')} \r\n"
@@ -401,19 +393,15 @@ def transfer_data_between_sockets(self, client_socket, server_socket):
                         client_socket.close()
                         server_socket.close()
                         bytes_sent = self.active_connections[thread_id]["bytes_sent"]
-                        bytes_received = self.active_connections[thread_id][
-                            "bytes_received"
-                        ]
+                        bytes_received = self.active_connections[thread_id]["bytes_received"]
                         self.active_connections.pop(threading.get_ident(), None)
                         return bytes_sent, bytes_received
                     if sock is client_socket:
                         server_socket.sendall(data)
                         self.active_connections[thread_id]["bytes_sent"] += len(data)
                     else:
                         client_socket.sendall(data)
-                        self.active_connections[thread_id]["bytes_received"] += len(
-                            data
-                        )
+                        self.active_connections[thread_id]["bytes_received"] += len(data)
         except (socket.error, OSError):
             client_socket.close()
             server_socket.close()

pyproxy/modules/filter.py

@@ -18,9 +18,7 @@
 import requests
 
 
-def load_blacklist(
-    blocked_sites_path: str, blocked_url_path: str, filter_mode: str
-) -> set:
+def load_blacklist(blocked_sites_path: str, blocked_url_path: str, filter_mode: str) -> set:
     """
     Loads blocked FQDNs or URLs from a file or URL into a set for fast lookup.
 
@@ -50,9 +48,7 @@ def load_from_http(url: str) -> set:
             for line in response.text.splitlines():
                 data.add(line.strip())
         except requests.exceptions.RequestException as e:
-            raise requests.exceptions.RequestException(
-                f"Failed to load data from {url}: {e}"
-            )
+            raise requests.exceptions.RequestException(f"Failed to load data from {url}: {e}")
         return data
 
     if filter_mode == "local":
@@ -88,12 +84,8 @@ def filter_process(
     manager = multiprocessing.Manager()
     blocked_data = manager.dict(
         {
-            "sites": load_blacklist(blocked_sites_path, blocked_url_path, filter_mode)[
-                0
-            ],
-            "urls": load_blacklist(blocked_sites_path, blocked_url_path, filter_mode)[
-                1
-            ],
+            "sites": load_blacklist(blocked_sites_path, blocked_url_path, filter_mode)[0],
+            "urls": load_blacklist(blocked_sites_path, blocked_url_path, filter_mode)[1],
         }
     )
 
@@ -136,13 +128,10 @@ def file_monitor() -> None:
                 full_url = server_host
 
             if "*" in blocked_data["sites"] or any(
-                server_host.startswith(blocked_host)
-                for blocked_host in blocked_data["sites"]
+                server_host.startswith(blocked_host) for blocked_host in blocked_data["sites"]
             ):
                 result_queue.put((server_host, "Blocked"))
-            elif any(
-                full_url.startswith(blocked_url) for blocked_url in blocked_data["urls"]
-            ):
+            elif any(full_url.startswith(blocked_url) for blocked_url in blocked_data["urls"]):
                 result_queue.put((full_url, "Blocked"))
             else:
                 result_queue.put((server_host, "Allowed"))

pyproxy/monitoring/__init__.py

@@ -35,4 +35,4 @@ def start_flask_server(proxy_server, flask_port, flask_pass, debug) -> None:
         log.setLevel(logging.ERROR)
 
     register_routes(app, auth, proxy_server, ProxyMonitor)
-    app.run(host="0.0.0.0", port=flask_port)  # nosec
+    app.run(host="0.0.0.0", port=flask_port)  # noqa: S104