Merge pull request #145 from JohanAlvedal/chore/pause-pylint-rules

feat(ci): reduce pylint rules

Author: etnoy

.pylintrc

@@ -2,7 +2,8 @@
 max-line-length=120
 
 [MASTER]
-disable=C0114,C0115,C0116,R0801
+# TODO: Enable the following checks when code is cleaned up
+disable=C0114,C0115,C0116,R0801,R0911,R0914,R0912
 ignore-paths=^tests/.*$
 score=no
 

custom_components/pumpsteer/__init__.py

@@ -1,4 +1,4 @@
-"""PumpSteer integration."""
+"""PumpSteer integration"""
 
 import logging
 from homeassistant.config_entries import ConfigEntry
@@ -11,18 +11,18 @@
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up the PumpSteer integration."""
+    """Set up the PumpSteer integration"""
     await hass.config_entries.async_forward_entry_setups(entry, ["sensor"])
 
     _LOGGER.info("PumpSteer integration setup completed")
     return True
 
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload the PumpSteer integration."""
+    """Unload the PumpSteer integration"""
     return await hass.config_entries.async_unload_platforms(entry, ["sensor"])
 
 
 async def async_get_options_flow():
-    """Return the options flow handler."""
+    """Return the options flow handler"""
     return PumpSteerOptionsFlowHandler()

custom_components/pumpsteer/config_flow.py

@@ -25,12 +25,12 @@
 
 
 class PumpSteerConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for pumpsteer."""
+    """Handle a config flow for pumpsteer"""
 
     VERSION = 1
 
     async def async_step_user(self, user_input=None):
-        """Handle the initial step of the config flow."""
+        """Handle the initial step of the config flow"""
         errors = {}
 
         if user_input is not None:
@@ -60,7 +60,7 @@ async def async_step_user(self, user_input=None):
         )
 
     async def _validate_entities(self, user_input):
-        """Validate that all required entities exist and are available."""
+        """Validate that all required entities exist and are available"""
         errors = {}
 
         # Only the entities that the user actually selects
@@ -113,11 +113,11 @@ async def _validate_entities(self, user_input):
         return errors
 
     async def _entity_exists(self, entity_id: str) -> bool:
-        """Check if entity exists in Home Assistant."""
+        """Check if entity exists in Home Assistant"""
         return self.hass.states.get(entity_id) is not None
 
     async def _entity_available(self, entity_id: str) -> bool:
-        """Check if entity is available (not unavailable or unknown)."""
+        """Check if entity is available (not unavailable or unknown)"""
         entity = self.hass.states.get(entity_id)
         if not entity:
             return False
@@ -129,11 +129,11 @@ async def _entity_available(self, entity_id: str) -> bool:
         ]
 
     def is_matching(self, other_flow: vol.Self) -> bool:
-        """Return True if other_flow is matching this flow."""
+        """Return True if other_flow is matching this flow"""
         raise NotImplementedError
 
     @staticmethod
     @callback
     def async_get_options_flow(config_entry):
-        """Get the options flow for this handler."""
+        """Get the options flow for this handler"""
         return PumpSteerOptionsFlowHandler()

custom_components/pumpsteer/ml_adaptive.py

@@ -1,12 +1,8 @@
-###############################################################################
-# PumpSteer - ML Adaptive Engine (Learning Version)
-# Author: Johan Älvedal / GPT-5 Assistant
-# Description:
 #   This version extends the original ML collector with richer data logging,
 #   session summaries, and a simple self-learning regression model that
 #   derives optimal inertia and aggressiveness based on comfort drift and
 #   duration performance.
-###############################################################################
+
 
 from datetime import datetime
 from pathlib import Path
@@ -37,7 +33,7 @@
 
 
 class PumpSteerMLCollector:
-    """Collects, analyzes, and learns from PumpSteer operation sessions."""
+    """Collects, analyzes, and learns from PumpSteer operation sessions"""
 
     def __init__(self, hass: HomeAssistant, data_file_path: str = ML_DATA_FILE_PATH):
         self.hass = hass
@@ -57,7 +53,7 @@ def __init__(self, hass: HomeAssistant, data_file_path: str = ML_DATA_FILE_PATH)
         )
 
     async def async_load_data(self) -> None:
-        """Load previously saved learning data from disk."""
+        """Load previously saved learning data from disk"""
         await self.hass.async_add_executor_job(self._load_data_sync)
         _LOGGER.info(
             "ML: Loaded %d sessions from %s",
@@ -104,7 +100,7 @@ def _save_data_sync(self) -> None:
             json.dump(data, f, indent=2)
 
     def start_session(self, initial_data: Dict[str, Any]) -> None:
-        """Start a new learning session."""
+        """Start a new learning session"""
         if self.current_session is not None:
             self.end_session("interrupted")
 
@@ -119,7 +115,7 @@ def start_session(self, initial_data: Dict[str, Any]) -> None:
         )
 
     def update_session(self, update_data: Dict[str, Any]) -> None:
-        """Add detailed data points to the ongoing session."""
+        """Add detailed data points to the ongoing session"""
         if self.current_session is None:
             return
 
@@ -150,7 +146,7 @@ def update_session(self, update_data: Dict[str, Any]) -> None:
     def end_session(
         self, reason: str = "normal", final_data: Optional[Dict[str, Any]] = None
     ) -> None:
-        """Close the session, summarize it, and learn from results."""
+        """Close the session, summarize it, and learn from results"""
         if self.current_session is None:
             return
 
@@ -233,7 +229,7 @@ def end_session(
         self.hass.async_create_task(self.async_save_data())
 
     def _update_learning_model(self) -> None:
-        """Perform a simple regression analysis on collected sessions."""
+        """Perform a simple regression analysis on collected sessions"""
         heating_sessions = [
             s
             for s in self.learning_sessions
@@ -315,7 +311,7 @@ def _update_learning_model(self) -> None:
         )
 
     def get_recommendations(self) -> List[str]:
-        """Generate adaptive recommendations based on learned model."""
+        """Generate adaptive recommendations based on learned model"""
         if not self.model_coefficients:
             return ["System is still learning — need more sessions."]
 
@@ -346,7 +342,7 @@ def get_recommendations(self) -> List[str]:
         return msg
 
     def get_learning_summary(self) -> Dict[str, Any]:
-        """Return current learning summary and model state."""
+        """Return current learning summary and model state"""
         return {
             "summary": self.learning_summary,
             "coefficients": self.model_coefficients,
@@ -355,7 +351,7 @@ def get_learning_summary(self) -> Dict[str, Any]:
         }
 
     async def async_shutdown(self) -> None:
-        """Graceful shutdown and data save."""
+        """Graceful shutdown and data save"""
         if self.current_session is not None:
             self.end_session("shutdown")
         await self.async_save_data()

custom_components/pumpsteer/ml_settings.py

@@ -64,7 +64,7 @@
 
 
 def validate_ml_settings() -> None:
-    """Validate ML-specific settings for consistency and logical values."""
+    """Validate ML-specific settings for consistency and logical values"""
     errors = []
 
     # Validate session thresholds
@@ -142,7 +142,7 @@ def validate_ml_settings() -> None:
 
 
 def get_ml_settings_info() -> dict:
-    """Get information about current ML settings."""
+    """Get information about current ML settings"""
     return {
         "version": ML_MODULE_VERSION,
         "data_file": ML_DATA_FILE_PATH,

custom_components/pumpsteer/options_flow.py

@@ -21,10 +21,10 @@
 
 
 class PumpSteerOptionsFlowHandler(config_entries.OptionsFlow):
-    """Handle options flow for pumpsteer."""
+    """Handle options flow for pumpsteer"""
 
     async def async_step_init(self, user_input=None):
-        """Manage the options flow."""
+        """Manage the options flow"""
         errors = {}
 
         entry = self.config_entry
@@ -69,7 +69,7 @@ async def async_step_init(self, user_input=None):
         )
 
     async def _validate_entities(self, user_input):
-        """Validate that entities exist and are available."""
+        """Validate that entities exist and are available"""
         errors = {}
 
         user_configurable_entities = {
@@ -118,11 +118,11 @@ async def _validate_entities(self, user_input):
         return errors
 
     async def _entity_exists(self, entity_id: str) -> bool:
-        """Check if entity exists."""
+        """Check if entity exists"""
         return self.hass.states.get(entity_id) is not None
 
     async def _entity_available(self, entity_id: str) -> bool:
-        """Check if entity is available."""
+        """Check if entity is available"""
         entity = self.hass.states.get(entity_id)
         if not entity:
             return False

custom_components/pumpsteer/sensor/__init__.py

@@ -11,7 +11,7 @@ async def async_setup_entry(
     config_entry: ConfigEntry,
     async_add_entities: AddEntitiesCallback,
 ) -> None:
-    """Register both control and ML analysis sensors."""
+    """Register both control and ML analysis sensors"""
     sensor = PumpSteerSensor(hass, config_entry)
     ml_sensor = PumpSteerMLSensor(hass, config_entry)
     async_add_entities([sensor, ml_sensor], update_before_add=True)

custom_components/pumpsteer/sensor/ml_sensor.py

@@ -27,10 +27,10 @@
 
 
 class PumpSteerMLSensor(Entity):
-    """Sensor that displays insights and learning results from PumpSteer ML."""
+    """Sensor that displays insights and learning results from PumpSteer ML"""
 
     def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry):
-        """Initialize ML sensor."""
+        """Initialize ML sensor"""
         self.hass = hass
         self._attr_name = "PumpSteer ML Analysis"
         self._attr_unique_id = f"{config_entry.entry_id}_ml_analysis"
@@ -72,7 +72,7 @@ def available(self) -> bool:
 
     @property
     def icon(self) -> str:
-        """Dynamic icon."""
+        """Dynamic icon"""
         if self._state == "error":
             return "mdi:alert-circle"
         if self._state == "collecting":
@@ -84,21 +84,21 @@ def icon(self) -> str:
         return "mdi:brain"
 
     async def async_added_to_hass(self):
-        """Load ML data on startup."""
+        """Load ML data on startup"""
         if self.ml and hasattr(self.ml, "async_load_data"):
             await self.ml.async_load_data()
             _LOGGER.debug("ML sensor: Data loaded successfully")
 
     async def async_will_remove_from_hass(self):
-        """Clean up when entity is removed."""
+        """Clean up when entity is removed"""
         if self.ml and hasattr(self.ml, "async_shutdown"):
             await self.ml.async_shutdown()
 
         self.ml = None
         await super().async_will_remove_from_hass()
 
     def _get_control_system_data(self) -> Dict[str, Any]:
-        """Fetch core control parameters from HA entities."""
+        """Fetch core control parameters from HA entities"""
 
         autotune_state = self.hass.states.get(ML_RELATED_ENTITIES["autotune_boolean"])
         autotune_on = autotune_state and autotune_state.state == "on"
@@ -127,7 +127,7 @@ def _get_control_system_data(self) -> Dict[str, Any]:
         }
 
     def _determine_state(self, insights: Dict[str, Any]) -> str:
-        """Decide what the main state string should be."""
+        """Decide what the main state string should be"""
         summary = insights.get("summary", {}) or {}
         total = summary.get("total_sessions", 0) or 0
         coeffs = summary.get("coefficients")
@@ -146,7 +146,7 @@ def _determine_state(self, insights: Dict[str, Any]) -> str:
     def _build_attributes(
         self, insights: Dict[str, Any], control_data: Dict[str, Any]
     ) -> Dict[str, Any]:
-        """Build a clear and concise attribute dictionary."""
+        """Build a clear and concise attribute dictionary"""
         summary = insights.get("summary", {})
         recs = insights.get("recommendations", [])
 
@@ -174,7 +174,7 @@ def _build_attributes(
         return {k: v for k, v in attributes.items() if v is not None}
 
     async def async_update(self):
-        """Refresh ML information and update sensor attributes."""
+        """Refresh ML information and update sensor attributes"""
         if not self.ml:
             self._state = STATE_UNAVAILABLE
             self._attributes = {
@@ -207,6 +207,6 @@ async def async_setup_entry(
     config_entry: ConfigEntry,
     async_add_entities: AddEntitiesCallback,
 ) -> None:
-    """Set up PumpSteer ML sensor entity."""
+    """Set up PumpSteer ML sensor entity"""
     ml_sensor = PumpSteerMLSensor(hass, config_entry)
     async_add_entities([ml_sensor], update_before_add=True)