more lint fixes

Author: noisecode3

database/data_factory.py

@@ -1,5 +1,6 @@
 """Index dictionary data definitions"""
 
+
 def make_trle_page_data():
     """trle.net page, represents the same data as a page on the site"""
     return {
@@ -24,6 +25,7 @@ def make_trle_level_data():
 
 
 def make_trle_tombll_data():
+    """This is the app data at the moment"""
     return {
         "title": "",
         "authors": [],
@@ -81,5 +83,3 @@ def make_zip_file():
         "release": "",
         "version": ""
     }
-
-

database/get_leaf_cert.py

@@ -1,8 +1,12 @@
-"""This module get the certificate for "broken" servers that don't follow
-   the standard handshake procedure, that is not sending the chain,
-   curl can still connect to this server by specifying the leaf and curl will
-   by default look for the chain in /etc/ssl/certs but requests module
-   require a bundle so that one would have to compile this bundle into the chain"""
+"""
+This module retrieves only the leaf certificate from servers that don't
+follow the standard TLS handshake procedure and fail to provide the complete
+certificate chain. While `curl` can still connect to these servers by
+specifying only the leaf certificate (and defaults to finding the chain in
+/etc/ssl/certs), the `requests` module requires a full certificate bundle.
+This module is intended for use cases where only the leaf certificate
+is needed.
+"""
 
 import sys
 import ssl
@@ -12,6 +16,7 @@
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes, serialization
 
+
 def get_certificate(hostname):
     """OpenSSL with TCP get the certificate"""
     context = ssl.create_default_context()
@@ -27,13 +32,15 @@ def get_certificate(hostname):
                 return x509.load_der_x509_certificate(cert_der, default_backend())
     return None
 
+
 def get_sha256_fingerprint(cert):
     """Identify the sum, we might want verify the certificate"""
     cert_der = cert.public_bytes(serialization.Encoding.DER)
     digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
     digest.update(cert_der)
     return digest.finalize()
 
+
 def get_serial_number_hex(cert):
     """Identify the serial, this can be use to look for the certificate"""
     # Get the serial number in a byte format
@@ -42,6 +49,7 @@ def get_serial_number_hex(cert):
     # Format it as a hex string
     return ':'.join(f'{b:02X}' for b in serial_number_bytes)
 
+
 def print_certificate_details(cert):
     """Log basic certificate information"""
     fingerprint = get_sha256_fingerprint(cert)
@@ -56,6 +64,7 @@ def print_certificate_details(cert):
 
 
 def run(url):
+    """Retrieve and return the certificate's public key in PEM byte format."""
     if url.startswith("https://www.trle.net"):
         host = 'trle.net'
     elif url.startswith("https://trcustoms.org"):
@@ -72,6 +81,7 @@ def run(url):
 
     return certificate.public_bytes(encoding=serialization.Encoding.PEM)
 
+
 '''
 def validate_downloaded_key(id_number, expected_serial):
     """Validate the certificate in binary form with the cryptography module"""

database/get_trle_by_id_range.py

@@ -2,23 +2,23 @@
 This script retrieves all TRLE levels by a specified ID range and saves the data as JSON files.
 Usage: python3 get_trle_by_id_range.py FROM_ID TO_ID
 """
-
 import sys
 import time
 import json
 
 import scrape
 import data_factory
 
+
 def safe_string_to_int(id_str):
     """Converts a string to an integer with error checking.
-    
+
     Args:
         s (str): The string to convert.
 
     Returns:
         int: The converted integer if valid.
-        
+
     Exits:
         Exits with status code 1 if the input string is not a valid integer.
     """
@@ -31,7 +31,7 @@ def safe_string_to_int(id_str):
 
 def trle_by_id(trle_id):
     """Fetches TRLE level data by ID and saves it as a JSON file.
-    
+
     Args:
         trle_id (int): The ID of the TRLE level to fetch.
     """

database/index_query.py

@@ -7,14 +7,15 @@
 # Set the working directory to the script's location to ensure relative paths work correctly
 os.chdir(os.path.dirname(os.path.abspath(__file__)))
 
+
 def check_trle_doubles():
     """
     Checks for duplicate entries in the Trle table.
-    
-    This function connects to the 'index.db' SQLite database and queries the Trle table 
-    to identify any duplicate records based on certain fields (trleExternId, author, 
-    title, difficulty, duration, class, type, and release). It groups the results by 
-    these fields and counts occurrences. If any grouped records appear more than once, 
+
+    This function connects to the 'index.db' SQLite database and queries the Trle table
+    to identify any duplicate records based on certain fields (trleExternId, author,
+    title, difficulty, duration, class, type, and release). It groups the results by
+    these fields and counts occurrences. If any grouped records appear more than once,
     they are considered duplicates, and those entries are returned and printed.
     """
     # Connect to the SQLite database
@@ -23,7 +24,7 @@ def check_trle_doubles():
 
     # Execute query to find duplicates
     result = query_return_fetchall("""
-        SELECT 
+        SELECT
             tr.trleExternId,
             tr.author,
             tr.title,
@@ -57,12 +58,12 @@ def check_trle_doubles():
 def query_return_fetchall(query, params, cursor):
     """
     Executes a SELECT query and fetches all results from the database.
-    
+
     Parameters:
     - query (str): The SQL query string to execute. Must be a SELECT query.
     - params (tuple or None): Parameters to bind to the query, or None if there are no parameters.
     - cursor (sqlite3.Cursor): The database cursor used to execute the query.
-    
+
     Returns:
     - list: The result set from the query as a list of tuples.
 
@@ -100,7 +101,7 @@ def query_return_id(query, params, cursor):
     - cursor (sqlite3.Cursor): The database cursor used to execute the query.
 
     Returns:
-    - int or None: The last inserted row ID if an INSERT query was run, 
+    - int or None: The last inserted row ID if an INSERT query was run,
                    or the first integer result from a SELECT query, if available.
                    Returns None if no valid result is found.
 
@@ -139,7 +140,7 @@ def query_return_id(query, params, cursor):
 def query_run(query, params, cursor):
     """
     Executes a query that does not return results (e.g., UPDATE, DELETE, or non-returning INSERT).
-    
+
     Parameters:
     - query (str): The SQL query to execute.
     - params (tuple): Parameters to bind to the query.

database/sanitize_downloads.py

@@ -7,6 +7,7 @@
 import json
 import re
 
+
 def new_input(data, file_path):
     """Take new input"""
     zip_file = data['zip_files'][0]
@@ -27,71 +28,57 @@ def new_input(data, file_path):
 def sanitize(data, file_path):
     """
     Validates the 'zip_file' data from the given dictionary.
-    
+
     This function checks:
     1. That the 'name' attribute exists and ends with ".zip".
     2. That the 'size' attribute is a float, greater than 2, and has exactly two decimal places.
     3. That the 'md5' attribute is a valid 32-character hexadecimal MD5 hash.
     4. That the 'url' attribute matches one of the allowed URL patterns.
-    
+
     Args:
         data (dict): The input dictionary containing 'zip_files' data.
-    
+
     Exits:
         Exits the program with status 1 if any validation fails.
     """
-
-    # Extract the first zip file data
     zip_file = data['zip_files'][0]
-
-    # Validate attributes
-    if not zip_file.get('name'):
-        print("The 'name' attribute is missing.")
-        new_input(data, file_path)
-        return
-
-    if not isinstance(zip_file.get('size'), float):
-        print("The 'size' attribute is missing.")
-        new_input(data, file_path)
-        return
-
-    if not zip_file.get('md5'):
-        print("The 'md5' attribute is missing.")
-        new_input(data, file_path)
-        return
-
-    if not zip_file.get('url'):
-        print("The 'url' attribute is missing.")
-        new_input(data, file_path)
-        return
-
-    # Validate name end with ".zip"
-    if not zip_file['name'].endswith(".zip") or "$" in zip_file['name']:
-        print(f"The file {zip_file['name']} is not a .zip file.")
-        new_input(data, file_path)
-        return
-
-    # Validate 'size' attribute - must be a float, >2, and have exactly two decimal places
-    if zip_file['size'] <= 2:
-        print("The 'size' attribute is smaller then 2 MiB")
-        new_input(data, file_path)
-        return
-
-    # Validate 'md5' attribute - must be a valid MD5 hash (32 hexadecimal characters)
-    if not re.fullmatch(r"^[a-fA-F0-9]{32}$", zip_file.get('md5', '')):
-        print("The 'md5' attribute is not a valid 32-character hexadecimal MD5 hash.")
-        new_input(data, file_path)
-        return
-
-    # Validate 'url' attribute - must match one of the expected patterns
+    errors = []
+
+    # Validate name
+    name = zip_file.get('name')
+    if not name:
+        errors.append("The 'name' attribute is missing.")
+    elif not name.endswith(".zip") or "$" in name:
+        errors.append(f"The file '{name}' is not a valid .zip file.")
+
+    # Validate size
+    size = zip_file.get('size')
+    if not isinstance(size, float):
+        errors.append("The 'size' attribute is missing or not a float.")
+    elif size <= 2:
+        errors.append("The 'size' attribute is smaller than 2 MiB.")
+
+    # Validate md5
+    md5 = zip_file.get('md5')
+    if not md5:
+        errors.append("The 'md5' attribute is missing.")
+    elif not re.fullmatch(r"^[a-fA-F0-9]{32}$", md5):
+        errors.append("The 'md5' attribute is not a valid 32-character hexadecimal MD5 hash.")
+
+    # Validate url
+    url = zip_file.get('url')
     pattern1 = r"^https://trcustoms\.org/api/level_files/\d+/download$"
     pattern2 = r"^https://www\.trle\.net/levels/levels/\d{4}/\d{4}/[a-zA-Z0-9%-_\.$]+\.zip$"
-
-    if not re.match(pattern1, zip_file.get('url', '')) \
-            and not re.match(pattern2, zip_file.get('url', '')):
-        print("The 'url' attribute does not match any of the expected patterns.")
+    if not url:
+        errors.append("The 'url' attribute is missing.")
+    elif not re.match(pattern1, url) and not re.match(pattern2, url):
+        errors.append("The 'url' attribute does not match any of the expected patterns.")
+
+    # Handle errors
+    if errors:
+        for error in errors:
+            print(error)
         new_input(data, file_path)
-        return
 
 
 def safe_string_to_int(id_str):