Fix CodeFactor issues

Author: Muriel2Horak

custom_components/oig_cloud/__init__.py

@@ -318,11 +318,16 @@ async def _setup_frontend_panel(hass: HomeAssistant, entry: ConfigEntry) -> None
         ):
             try:
                 frontend.async_remove_panel(hass, panel_id, warn_if_unknown=False)
-            except Exception:
+            except Exception as err:
                 try:
                     frontend.async_remove_panel(hass, panel_id)
-                except Exception:
-                    pass
+                except Exception as fallback_err:
+                    _LOGGER.debug(
+                        "Failed to remove panel %s: %s (fallback: %s)",
+                        panel_id,
+                        err,
+                        fallback_err,
+                    )
 
         # OPRAVA: Kontrola existence funkce a její volání bez await pokud vrací None
         if hasattr(frontend, "async_register_built_in_panel"):

custom_components/oig_cloud/api/api_chmu.py

@@ -125,13 +125,19 @@ async def _resolve_latest_cap_url(self, session: aiohttp.ClientSession) -> str:
                         )
                     index_html = await response.text()
 
+            def _parse_index_dt(value: str) -> Optional[datetime]:
+                try:
+                    return datetime.strptime(value, "%d-%b-%Y %H:%M")
+                except Exception as err:
+                    _LOGGER.debug("Skipping CAP index entry '%s': %s", value, err)
+                    return None
+
             items: list[tuple[datetime, str, str]] = []
             for m in self._AUTO_INDEX_RE.finditer(index_html):
-                try:
-                    dt = datetime.strptime(m.group("dt"), "%d-%b-%Y %H:%M")
-                    items.append((dt, m.group("series"), m.group("file")))
-                except Exception:
+                dt = _parse_index_dt(m.group("dt"))
+                if dt is None:
                     continue
+                items.append((dt, m.group("series"), m.group("file")))
 
             if not items:
                 raise ChmuApiError("CAP index neobsahuje žádné alert_cap_*.xml soubory")
@@ -164,7 +170,7 @@ def _parse_cap_xml(self, xml_text: str) -> List[Dict[str, Any]]:
             Seznam varování (raw data z XML)
         """
         try:
-            root = ET.fromstring(xml_text)
+            root = ET.fromstring(xml_text)  # nosec B314
         except ET.ParseError as e:
             _LOGGER.error(f"Chyba parsování CAP XML: {e}")
             return []

custom_components/oig_cloud/api/ote_api.py

@@ -289,7 +289,7 @@ async def _download_soap(self, body_xml: str, action: str) -> str:
 
     def _parse_soap_response(self, soap_response: str) -> ET.Element:
         try:
-            root = ET.fromstring(soap_response)
+            root = ET.fromstring(soap_response)  # nosec B314
         except Exception as e:
             if "Application is not available" in soap_response:
                 raise UpdateFailed("OTE Portal is currently not available!") from e

custom_components/oig_cloud/config_flow_wizard.py

@@ -1060,6 +1060,6 @@ async def _detect_fve_power(self) -> float:
                     state = self.hass.states.get(entity.entity_id)
                     if state and state.state not in ("unknown", "unavailable"):
                         return round(float(state.state) / 1000, 1)
-        except Exception:
-            pass
+        except Exception as err:
+            _LOGGER.debug("Auto-detect FVE power failed: %s", err)
         return 5.4  # Default

custom_components/oig_cloud/data_source.py

@@ -126,8 +126,8 @@ def _parse_dt(value: Any) -> Optional[dt_util.dt.datetime]:
                 if ts > 1_000_000_000_000:  # ms epoch
                     ts = ts / 1000.0
                 return dt_util.dt.datetime.fromtimestamp(ts, tz=dt_util.UTC)
-            except Exception:
-                pass
+            except Exception as err:
+                _LOGGER.debug("Failed to parse numeric timestamp '%s': %s", value, err)
         dt = dt_util.parse_datetime(value)
         if dt is None:
             try:
@@ -325,8 +325,8 @@ async def async_start(self) -> None:
                 ):
                     snap = self.telemetry_store.get_snapshot()
                     self.coordinator.async_set_updated_data(snap.payload)
-        except Exception:
-            pass
+        except Exception as err:
+            _LOGGER.debug("Failed to seed local telemetry snapshot: %s", err)
 
         # Watch proxy last_data changes
         if _async_track_state_change_event is not None:
@@ -369,8 +369,8 @@ async def async_stop(self) -> None:
         for unsub in self._unsubs:
             try:
                 unsub()
-            except Exception:
-                pass
+            except Exception as err:
+                _LOGGER.debug("Failed to unsubscribe data source listener: %s", err)
         self._unsubs.clear()
 
     @callback
@@ -396,8 +396,8 @@ def _on_any_state_change(self, event: Any) -> None:
             state = get_data_source_state(self.hass, self.entry.entry_id)
             if state.effective_mode == DATA_SOURCE_CLOUD_ONLY:
                 return
-        except Exception:
-            pass
+        except Exception as err:
+            _LOGGER.debug("Failed to read data source state: %s", err)
 
         entity_id = event.data.get("entity_id")
         if not isinstance(entity_id, str):
@@ -444,8 +444,8 @@ def _on_any_state_change(self, event: Any) -> None:
     def _schedule_debounced_poke(self) -> None:
         try:
             self.hass.async_create_task(self._debouncer.async_call())
-        except Exception:
-            pass
+        except Exception as err:
+            _LOGGER.debug("Failed to schedule local telemetry debounce: %s", err)
 
     async def _handle_local_event(self) -> None:
         """Debounced handler for local telemetry changes.
@@ -469,8 +469,8 @@ async def _handle_local_event(self) -> None:
                     ):
                         snap = self.telemetry_store.get_snapshot()
                         self.coordinator.async_set_updated_data(snap.payload)
-        except Exception:
-            pass
+        except Exception as err:
+            _LOGGER.debug("Failed to handle local telemetry event: %s", err)
 
     @callback
     def _update_state(self, force: bool = False) -> tuple[bool, bool]:
@@ -611,19 +611,19 @@ def _on_effective_mode_changed(self) -> None:
                     "reason": state.reason,
                 },
             )
-        except Exception:
-            pass
+        except Exception as err:
+            _LOGGER.debug("Failed to fire data source change event: %s", err)
 
         if state.effective_mode == DATA_SOURCE_CLOUD_ONLY:
             # Ensure cloud data is fresh when falling back
             try:
                 self.hass.async_create_task(self.coordinator.async_request_refresh())
-            except Exception:
-                pass
+            except Exception as err:
+                _LOGGER.debug("Failed to schedule coordinator refresh: %s", err)
 
     async def _poke_coordinator(self) -> None:
         try:
             if self.coordinator and getattr(self.coordinator, "data", None) is not None:
                 self.coordinator.async_set_updated_data(self.coordinator.data)
-        except Exception:
-            pass
+        except Exception as err:
+            _LOGGER.debug("Failed to poke coordinator: %s", err)

custom_components/oig_cloud/oig_cloud_battery_balancing.py

@@ -299,8 +299,8 @@ async def async_added_to_hass(self) -> None:
                 if attrs.get("days_since_last") is not None:
                     try:
                         self._days_since_last = int(attrs.get("days_since_last"))
-                    except Exception:
-                        pass
+                    except Exception as err:
+                        _LOGGER.debug("Failed to restore days_since_last: %s", err)
                 self._planned_window = attrs.get("planned") or self._planned_window
                 self._cost_immediate = attrs.get(
                     "cost_immediate_czk", self._cost_immediate
@@ -309,8 +309,8 @@ async def async_added_to_hass(self) -> None:
                     "cost_selected_czk", self._cost_selected
                 )
                 self._cost_savings = attrs.get("cost_savings_czk", self._cost_savings)
-        except Exception:
-            pass
+        except Exception as err:
+            _LOGGER.debug("Failed to restore balancing state: %s", err)
 
         # Initial update
         self._update_from_manager()

custom_components/oig_cloud/oig_cloud_battery_health_old.py

@@ -1256,8 +1256,8 @@ def _save():
             try:
                 cycle_id = self._generate_cycle_id(measurement.timestamp)
                 self._processing_cycle_ids.discard(cycle_id)
-            except Exception:
-                pass
+            except Exception as err:
+                _LOGGER.debug("Failed to clear processing cycle id: %s", err)
 
     async def _find_data_availability_window(
         self,

custom_components/oig_cloud/oig_cloud_computed_sensor.py

@@ -714,6 +714,8 @@ def _cancel_reset(self) -> None:
         if unsub:
             try:
                 unsub()
-            except Exception:
-                pass
+            except Exception as err:
+                _LOGGER.debug(
+                    "[%s] Failed to cancel daily reset listener: %s", self.entity_id, err
+                )
             self._daily_reset_unsub = None

custom_components/oig_cloud/oig_cloud_coordinator.py

@@ -280,8 +280,8 @@ async def _save() -> None:
 
         try:
             self.hass.async_create_task(_save())
-        except Exception:
-            pass
+        except Exception as err:
+            _LOGGER.debug("Failed to schedule coordinator cache save: %s", err)
 
     def update_intervals(self, standard_interval: int, extended_interval: int) -> None:
         """Dynamicky aktualizuje intervaly coordinatoru."""
@@ -536,8 +536,8 @@ async def _async_update_data(self) -> Dict[str, Any]:  # noqa: C901
                 try:
                     if isinstance(stats, dict):
                         await self._maybe_fill_config_nodes_from_cloud(stats)
-                except Exception:
-                    pass
+                except Exception as err:
+                    _LOGGER.debug("Failed to fill config nodes from cloud: %s", err)
 
             # Cloud notifications are optional and should never run in local/hybrid effective mode.
             cloud_notifications_enabled = bool(

custom_components/oig_cloud/oig_cloud_data_sensor.py

@@ -106,14 +106,22 @@ async def async_will_remove_from_hass(self) -> None:
         if self._local_state_unsub:
             try:
                 self._local_state_unsub()
-            except Exception:
-                pass
+            except Exception as err:
+                _LOGGER.debug(
+                    "[%s] Failed to unsubscribe local state listener: %s",
+                    self.entity_id,
+                    err,
+                )
             self._local_state_unsub = None
         if self._data_source_unsub:
             try:
                 self._data_source_unsub()
-            except Exception:
-                pass
+            except Exception as err:
+                _LOGGER.debug(
+                    "[%s] Failed to unsubscribe data source listener: %s",
+                    self.entity_id,
+                    err,
+                )
             self._data_source_unsub = None
         await super().async_will_remove_from_hass()