v0.14.10 Release Candidate (#248)

- Release lingering resources to meet tighter Python requirements
- Update regression tests for Python 3.13  compatibility

Author: vasqued2

.github/workflows/pylint.yaml

@@ -11,11 +11,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.12"]
+        python-version: ["3.13"]
     steps:
     - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies

.github/workflows/pytest.yaml

@@ -11,12 +11,12 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.11', '3.12']
+        python-version: ['3.11', '3.12', '3.13']
 
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install dependencies
@@ -30,6 +30,6 @@ jobs:
           pip install pytest-cov
           pytest ./tests/ --cov=custom_components/teamtracker/ --cov-report=xml
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         env: 
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

custom_components/teamtracker/__init__.py

@@ -112,8 +112,11 @@ async def async_call_api_service(call):
         VERSION,
         ISSUE_URL,
     )
-    hass.data.setdefault(DOMAIN, {})
 
+    # Initialize DOMAIN in hass.data if it doesn't exist
+    if DOMAIN not in hass.data:
+        hass.data[DOMAIN] = {}
+        
     entry.async_on_unload(entry.add_update_listener(update_options_listener))
 
     if entry.unique_id is not None:
@@ -153,6 +156,14 @@ async def async_call_api_service(call):
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Handle removal of an entry."""
 
+    # Shut down the coordinator first to close aiohttp session
+    if entry.entry_id in hass.data[DOMAIN]:
+        coordinator = hass.data[DOMAIN][entry.entry_id].get(COORDINATOR)
+        if coordinator:
+            if hasattr(coordinator, "async_unload"):
+                await coordinator.async_unload()
+                
+    # Unload platforms
     unload_ok = all(
         await asyncio.gather(
             *[
@@ -164,6 +175,13 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     if unload_ok:
         hass.data[DOMAIN].pop(entry.entry_id)
+        
+        # Only remove service if this is the last entry
+        if not hass.data[DOMAIN]:
+            hass.services.async_remove(DOMAIN, SERVICE_NAME_CALL_API)
+            TeamTrackerDataUpdateCoordinator.data_cache.clear()
+            TeamTrackerDataUpdateCoordinator.last_update.clear()
+            TeamTrackerDataUpdateCoordinator.c_cache.clear()
 
     return unload_ok
 
@@ -227,12 +245,27 @@ def __init__(self, hass, config, entry: ConfigEntry=None):
         self.config = config
         self.hass = hass
         self.entry = entry #None if setup from YAML
+        self._session = None  # ADD: Track aiohttp session
 
         super().__init__(hass, _LOGGER, name=self.name, update_interval=DEFAULT_REFRESH_RATE)
         _LOGGER.debug(
             "%s: Using default refresh rate (%s)", self.name, self.update_interval
         )
 
+    # ADD: New method to get or create session
+    async def _get_session(self):
+        """Get or create aiohttp session."""
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession()
+        return self._session
+
+    # ADD: New method to cleanup
+    async def async_shutdown(self):
+        """Cleanup coordinator resources."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            _LOGGER.debug("%s: Closed aiohttp session", self.name)
+
 
     #
     #  Return the language to use for the API
@@ -401,19 +434,20 @@ async def async_call_api(self, config, hass, lang) -> dict:
                 contents = await f.read()
             data = json.loads(contents)
         else:
-            async with aiohttp.ClientSession() as session:
-                try:
-                    async with session.get(url, headers=headers) as r:
-                        _LOGGER.debug(
-                            "%s: Calling API for '%s' from %s",
-                            sensor_name,
-                            team_id,
-                            url,
-                        )
-                        if r.status == 200:
-                            data = await r.json()
-                except:
-                    data = None
+            session = await self._get_session()
+            try:
+                async with session.get(url, headers=headers) as r:
+                    _LOGGER.debug(
+                        "%s: Calling API for '%s' from %s",
+                        sensor_name,
+                        team_id,
+                        url,
+                    )
+                    if r.status == 200:
+                        data = await r.json()
+            except Exception as e: # pylint: disable=broad-exception-caught
+                _LOGGER.debug("%s: API call failed: %s", sensor_name, e)
+                data = None
 
             num_events = 0
             if data is not None:
@@ -434,6 +468,8 @@ async def async_call_api(self, config, hass, lang) -> dict:
                 num_events,
                 url,
             )
+            
+            # First fallback - without date constraint
             if num_events == 0:
                 url_parms = "?lang=" + lang[:2]
                 if self.conference_id:
@@ -443,19 +479,19 @@ async def async_call_api(self, config, hass, lang) -> dict:
 
                 url = URL_HEAD + sport_path + "/" + league_path + URL_TAIL + url_parms
 
-                async with aiohttp.ClientSession() as session:
-                    try:
-                        async with session.get(url, headers=headers) as r:
-                            _LOGGER.debug(
-                                "%s: Calling API without date constraint for '%s' from %s",
-                                sensor_name,
-                                team_id,
-                                url,
-                            )
-                            if r.status == 200:
-                                data = await r.json()
-                    except:
-                        data = None
+                try:
+                    async with session.get(url, headers=headers) as r:
+                        _LOGGER.debug(
+                            "%s: Calling API without date constraint for '%s' from %s",
+                            sensor_name,
+                            team_id,
+                            url,
+                        )
+                        if r.status == 200:
+                            data = await r.json()
+                except Exception as e: # pylint: disable=broad-exception-caught
+                    _LOGGER.debug("%s: API call failed: %s", sensor_name, e)
+                    data = None
 
                 num_events = 0
                 if data is not None:
@@ -465,7 +501,6 @@ async def async_call_api(self, config, hass, lang) -> dict:
                         team_id,
                         url,
                     )
-
                     try:
                         num_events = len(data["events"])
                     except:
@@ -478,6 +513,7 @@ async def async_call_api(self, config, hass, lang) -> dict:
                     url,
                 )
 
+            # Second fallback - without language
             if num_events == 0:
                 url_parms = ""
                 if self.conference_id:
@@ -487,23 +523,25 @@ async def async_call_api(self, config, hass, lang) -> dict:
 
                 url = URL_HEAD + sport_path + "/" + league_path + URL_TAIL + url_parms
 
-                async with aiohttp.ClientSession() as session:
-                    try:
-                        async with session.get(url, headers=headers) as r:
-                            _LOGGER.debug(
-                                "%s: Calling API without language for '%s' from %s",
-                                sensor_name,
-                                team_id,
-                                url,
-                            )
-                            if r.status == 200:
-                                data = await r.json()
-                    except:
-                        data = None
+                try:
+                    async with session.get(url, headers=headers) as r:
+                        _LOGGER.debug(
+                            "%s: Calling API without language for '%s' from %s",
+                            sensor_name,
+                            team_id,
+                            url,
+                        )
+                        if r.status == 200:
+                            data = await r.json()
+                except Exception as e: # pylint: disable=broad-exception-caught
+                    _LOGGER.debug("%s: API call failed: %s", sensor_name, e)
+                    data = None
+                    
         self.api_url = url
 
         return data, file_override
 
+
     async def async_update_values(self, config, hass, data, lang) -> dict:
         """Return values based on the data passed into method"""