linting

Author: michelangelomo

backend/app/api/events.py

@@ -2,8 +2,6 @@
 import logging
 
 from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
-
-logger = logging.getLogger(__name__)
 from fastapi.responses import StreamingResponse
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -14,6 +12,8 @@
 from app.models.node_event import NodeEvent
 from app.services.sse import sse_manager
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/api", tags=["events"])
 
 

backend/app/api/pathfinder.py

@@ -1,5 +1,4 @@
 import logging
-from uuid import UUID
 
 from fastapi import APIRouter, BackgroundTasks, Depends
 from sqlalchemy import select
@@ -8,8 +7,6 @@
 
 from app.auth import get_current_user
 from app.database import get_db
-
-logger = logging.getLogger(__name__)
 from app.models.node import Node
 from app.schemas.path import HopInfo, PathRequest, PathResult
 from app.services.pathfinder import (
@@ -18,6 +15,8 @@
     find_max_min_snr_path,
 )
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/api/path", tags=["pathfinder"])
 
 

backend/app/models/coverage_cache.py

@@ -1,5 +1,4 @@
 import uuid
-from datetime import datetime
 
 from sqlalchemy import Boolean, Column, DateTime, ForeignKey, LargeBinary, String
 from sqlalchemy.dialects.postgresql import UUID

backend/app/services/splat.py

@@ -301,9 +301,6 @@ def _calculate_required_terrain_tiles(
                 # .sdf file boundaries
                 lat_start = lat_tile
                 lon_start = lon_tile
-                lat_end = lat_start + 1
-                lon_end = lon_start + 1
-
                 # Generate .sdf file names
                 sdf_filename = Splat._hgt_filename_to_sdf_filename(tile_name, high_resolution = False)
                 sdf_hd_filename = Splat._hgt_filename_to_sdf_filename(tile_name, high_resolution = True)

backend/tests/test_coverage.py

@@ -9,17 +9,12 @@
 """
 from __future__ import annotations
 
-import io
-import math
-import struct
 import textwrap
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import numpy as np
 import pytest
-import rasterio
 from rasterio.io import MemoryFile
-from rasterio.transform import from_bounds
 
 from app.models.coverage_request import CoveragePredictionRequest
 from app.services.clutter import (
@@ -227,39 +222,39 @@ def test_climate_enumeration(self):
         }
         for name, expected_int in climates.items():
             content = self._make_lrp(radio_climate=name)
-            lines = [l.split(";")[0].strip() for l in content.strip().split("\n")]
+            lines = [ln.split(";")[0].strip() for ln in content.strip().split("\n")]
             assert lines[4] == str(expected_int), f"{name} should map to {expected_int}"
 
     def test_polarization_enumeration(self):
         h_content = self._make_lrp(polarization="horizontal")
         v_content = self._make_lrp(polarization="vertical")
-        h_line = [l.split(";")[0].strip() for l in h_content.split("\n")][5]
-        v_line = [l.split(";")[0].strip() for l in v_content.split("\n")][5]
+        h_line = [ln.split(";")[0].strip() for ln in h_content.split("\n")][5]
+        v_line = [ln.split(";")[0].strip() for ln in v_content.split("\n")][5]
         assert h_line == "0"
         assert v_line == "1"
 
     def test_situation_fraction_normalized(self):
         content = self._make_lrp(situation_fraction=50.0)
-        lines = [l.split(";")[0].strip() for l in content.strip().split("\n")]
+        lines = [ln.split(";")[0].strip() for ln in content.strip().split("\n")]
         assert float(lines[6]) == pytest.approx(0.50)
 
     def test_time_fraction_normalized(self):
         content = self._make_lrp(time_fraction=90.0)
-        lines = [l.split(";")[0].strip() for l in content.strip().split("\n")]
+        lines = [ln.split(";")[0].strip() for ln in content.strip().split("\n")]
         assert float(lines[7]) == pytest.approx(0.90)
 
     def test_erp_calculation(self):
         # ERP = 10^((tx_power + tx_gain - system_loss - 30) / 10) Watts
         # The LRP file formats ERP with %.2f, so we allow rounding tolerance.
         content = self._make_lrp(tx_power=17.0, tx_gain=2.0, system_loss=2.0)
-        lines = [l.split(";")[0].strip() for l in content.strip().split("\n")]
+        lines = [ln.split(";")[0].strip() for ln in content.strip().split("\n")]
         expected_erp = 10 ** ((17.0 + 2.0 - 2.0 - 30) / 10)
         assert float(lines[8]) == pytest.approx(expected_erp, abs=0.01)
 
     def test_erp_with_zero_gain_loss(self):
         # 20 dBm, 0 dB gain, 0 dB loss → 10^((20-30)/10) = 0.1 W
         content = self._make_lrp(tx_power=20.0, tx_gain=0.0, system_loss=0.0)
-        lines = [l.split(";")[0].strip() for l in content.strip().split("\n")]
+        lines = [ln.split(";")[0].strip() for ln in content.strip().split("\n")]
         assert float(lines[8]) == pytest.approx(0.1, rel=1e-3)
 
     def test_frequency_in_content(self):
@@ -278,31 +273,31 @@ def test_returns_bytes(self):
 
     def test_has_32_levels(self):
         content = Splat._create_splat_dcf("plasma", -130.0, -80.0).decode()
-        data_lines = [l for l in content.split("\n") if l.strip() and not l.startswith(";")]
+        data_lines = [ln for ln in content.split("\n") if ln.strip() and not ln.startswith(";")]
         assert len(data_lines) == 32
 
     def test_levels_from_max_to_min(self):
         content = Splat._create_splat_dcf("plasma", -130.0, -80.0).decode()
-        data_lines = [l for l in content.split("\n") if l.strip() and not l.startswith(";")]
+        data_lines = [ln for ln in content.split("\n") if ln.strip() and not ln.startswith(";")]
         first_dbm = int(data_lines[0].split(":")[0].strip())
         last_dbm = int(data_lines[-1].split(":")[0].strip())
         assert first_dbm > last_dbm  # max at top, min at bottom
 
     def test_max_dbm_is_first_level(self):
         content = Splat._create_splat_dcf("plasma", -130.0, -80.0).decode()
-        data_lines = [l for l in content.split("\n") if l.strip() and not l.startswith(";")]
+        data_lines = [ln for ln in content.split("\n") if ln.strip() and not ln.startswith(";")]
         first_dbm = int(data_lines[0].split(":")[0].strip())
         assert first_dbm == -80
 
     def test_min_dbm_is_last_level(self):
         content = Splat._create_splat_dcf("plasma", -130.0, -80.0).decode()
-        data_lines = [l for l in content.split("\n") if l.strip() and not l.startswith(";")]
+        data_lines = [ln for ln in content.split("\n") if ln.strip() and not ln.startswith(";")]
         last_dbm = int(data_lines[-1].split(":")[0].strip())
         assert last_dbm == -130
 
     def test_rgb_values_in_range(self):
         content = Splat._create_splat_dcf("plasma", -130.0, -80.0).decode()
-        data_lines = [l for l in content.split("\n") if l.strip() and not l.startswith(";")]
+        data_lines = [ln for ln in content.split("\n") if ln.strip() and not ln.startswith(";")]
         for line in data_lines:
             rgb_part = line.split(":")[1]
             r, g, b = [int(x) for x in rgb_part.split(",")]

backend/tests/test_pathfinder.py

@@ -11,19 +11,15 @@
 from __future__ import annotations
 
 import math
-import struct
-from typing import List, Optional
-from unittest.mock import patch
+from typing import Optional
 
 import numpy as np
 import pytest
-import rasterio
 from rasterio.io import MemoryFile
 from rasterio.transform import from_bounds
 
 from app.services.pathfinder import (
     COVERAGE_DYNAMIC_RANGE_DB,
-    LORA_PRESETS,
     GraphNode,
     _FRIIS_ONLY_PENALTY_DB,
     _LORA_MIN_SNR_DB,