MBTAclient 0.2.6__tar.gz → 0.2.8__tar.gz

{mbtaclient-0.2.6 → mbtaclient-0.2.8}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: MBTAclient
-Version: 0.2.6
+Version: 0.2.8
 Summary: A Python client for interacting with the MBTA API
 Author-email: Luca Chiabrera <luca.chiabrera@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/chiabre/MBTAclient
 Project-URL: Issues, https://github.com/chiabre/MBTAclient/issues
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12

{mbtaclient-0.2.6 → mbtaclient-0.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MBTAclient"
-version = "0.2.6"
+version = "0.2.8"
 description = "A Python client for interacting with the MBTA API"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -15,7 +15,7 @@ dependencies = [
 license = { text = "MIT" }
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.12",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent"
 ]

{mbtaclient-0.2.6 → mbtaclient-0.2.8}/src/MBTAclient.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: MBTAclient
-Version: 0.2.6
+Version: 0.2.8
 Summary: A Python client for interacting with the MBTA API
 Author-email: Luca Chiabrera <luca.chiabrera@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/chiabre/MBTAclient
 Project-URL: Issues, https://github.com/chiabre/MBTAclient/issues
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12

{mbtaclient-0.2.6 → mbtaclient-0.2.8}/src/MBTAclient.egg-info/SOURCES.txt

@@ -20,4 +20,13 @@ src/mbtaclient/mbta_schedule.py
 src/mbtaclient/mbta_stop.py
 src/mbtaclient/mbta_trip.py
 src/mbtaclient/mbta_utils.py
-src/mbtaclient/trip_handler.py
+src/mbtaclient/trip_handler.py
+tests/test_journey_stop.py
+tests/test_mbta_alert.py
+tests/test_mbta_client.py
+tests/test_mbta_prediction.py
+tests/test_mbta_route.py
+tests/test_mbta_schedule.py
+tests/test_mbta_stop.py
+tests/test_mbta_trip.py
+tests/test_mbta_utils.py

{mbtaclient-0.2.6 → mbtaclient-0.2.8}/src/mbtaclient/base_handler.py

@@ -31,15 +31,23 @@ class BaseHandler:
         }
         
         client_session = session or aiohttp.ClientSession()
-        self.mbta_client = MBTAClient(client_session,logger,api_key)
+        self.mbta_client = MBTAClient(client_session, logger, api_key)
 
         self.journeys: dict[str, Journey] = {} 
 
         self.logger: logging.Logger = logger or logging.getLogger(__name__)
         
     def __repr__(self) -> str:
-        return (f"BaseHandler(depart_from_name={self.depart_from['name']}, arrive_at_name={self.arrive_at['name']})")
+        return "BaseHandler(depart_from_name={}, arrive_at_name={})".format(self.depart_from['name'], self.arrive_at['name'])
  
+    async def __aenter__(self):
+        # Entering context, initialize and return the handler
+        await self._async_init()
+        return self
+    
+    async def __aexit__(self, exc_type, exc, tb):
+        # Exit context, clean up resources if necessary
+        await self.mbta_client.close()
         
     async def _async_init(self):
         stops = await self.__fetch_stops()
@@ -47,16 +55,19 @@ class BaseHandler:
     
     @memoize_async()
     async def __fetch_stops(self, params: dict = None) -> list[MBTAStop]:
-        """Retrive stops """
-        self.logger.debug("Retriving MBTA stops")
+        """Retrieve stops."""
+        self.logger.debug("Retrieving MBTA stops")
         base_params = {'filter[location_type]': '0'}
         if params is not None:
             base_params.update(params)
         try:
             stops: list[MBTAStop] = await self.mbta_client.list_stops(base_params)
             return stops
+        except aiohttp.ClientError as e:
+            self.logger.error("HTTP error occurred while retrieving MBTA stops: {}".format(e))
+            return []
         except Exception as e:
-            self.logger.error(f"Error retriving MBTA stops: {e}")
+            self.logger.error("Error retrieving MBTA stops: {}".format(e))
             return []
         
     def __process_stops(self, stops: list[MBTAStop]):
@@ -68,7 +79,7 @@ class BaseHandler:
 
         for stop in stops:
             if not isinstance(stop, MBTAStop):  # Validate data type
-                self.logger.warning(f"Unexpected data type for stop: {type(stop)}")
+                self.logger.warning("Unexpected data type for stop: {}".format(type(stop)))
                 continue  # Skip invalid data
 
             if stop.name.lower() == self.depart_from['name'].lower():
@@ -80,12 +91,12 @@ class BaseHandler:
                 arrive_at_ids.append(stop.id)
 
         if len(depart_from_stops) == 0:
-            self.logger.error(f"Error processing MBTA stop data for {self.depart_from['name']}")
-            raise MBTAStopError(f"Invalid stop name: {self.depart_from['name']}")
+            self.logger.error("Error processing MBTA stop data for {}".format(self.depart_from['name']))
+            raise MBTAStopError("Invalid stop name: {}".format(self.depart_from['name']))
 
         if len(arrive_at_stops) == 0:
-            self.logger.error(f"Error processing MBTA stop data for {self.arrive_at['name']}")
-            raise MBTAStopError(f"Invalid stop name: {self.arrive_at['name']}")
+            self.logger.error("Error processing MBTA stop data for {}".format(self.arrive_at['name']))
+            raise MBTAStopError("Invalid stop name: {}".format(self.arrive_at['name']))
 
         self.depart_from['stops'] = depart_from_stops
         self.depart_from['ids'] = depart_from_ids
@@ -99,19 +110,19 @@ class BaseHandler:
         return None
     
     def _get_stops_ids(self) -> list[str]:
-        return  self.depart_from['ids'] + self.arrive_at['ids']         
+        return self.depart_from['ids'] + self.arrive_at['ids']         
     
     def __get_stops_ids_by_stop_type(self, stop_type: str) -> Optional[list[str]]:
         if stop_type == 'departure':
             return self.depart_from['ids']
         elif stop_type == 'arrival':
             return self.arrive_at['ids']  
-        return None           
+        return None
     
     @memoize_async(expire_at_end_of_day=True)
     async def _fetch_schedules(self, params: Optional[dict] = None) -> list[MBTASchedule]:
-        """Retrive MBTA schedules"""
-        self.logger.debug("Retriving MBTA schedules")
+        """Retrieve MBTA schedules"""
+        self.logger.debug("Retrieving MBTA schedules")
         base_params = {
             'filter[stop]': ','.join(self._get_stops_ids()),
             'sort': 'departure_time'
@@ -121,8 +132,11 @@ class BaseHandler:
         try:
             schedules: list[MBTASchedule] = await self.mbta_client.list_schedules(params)
             return schedules
+        except aiohttp.ClientError as e:
+            self.logger.error("HTTP error occurred while retrieving MBTA schedules: {}".format(e))
+            return []
         except Exception as e:
-            self.logger.error(f"Error retriving MBTA schedules: {e}")
+            self.logger.error("Error retrieving MBTA schedules: {}".format(e))
             return []
             
     async def _process_schedules(self, schedules: list[MBTASchedule]):
@@ -131,7 +145,7 @@ class BaseHandler:
         for schedule in schedules:
             # Validate schedule data
             if not schedule.trip_id or not schedule.stop_id:
-                self.logger.error(f"Invalid schedule data: {schedule}")
+                self.logger.error("Invalid schedule data: {}".format(schedule))
                 continue  # Skip to the next schedule
 
             # If the schedule trip_id is not in the journeys
@@ -144,7 +158,7 @@ class BaseHandler:
             # Validate stop
             stop = self.__get_stop_by_id(schedule.stop_id)
             if not stop:
-                self.logger.debug(f"Stop {schedule.stop_id} of schedule {schedule.id} doesn't belong to the journey stop ids")
+                self.logger.debug("Stop {} of schedule {} doesn't belong to the journey stop ids".format(schedule.stop_id, schedule.id))
                 continue  # Skip to the next schedule
 
             departure_stops_ids = self.__get_stops_ids_by_stop_type('departure')
@@ -156,13 +170,11 @@ class BaseHandler:
             elif schedule.stop_id in arrival_stops_ids:
                 self.journeys[schedule.trip_id].add_stop('arrival', schedule, stop, 'SCHEDULED')
             else:
-                self.logger.warning(f"Stop ID {schedule.stop_id} is not categorized as departure or arrival for schedule: {schedule}")
-        
-    
+                self.logger.warning("Stop ID {} is not categorized as departure or arrival for schedule: {}".format(schedule.stop_id, schedule))
 
     async def _fetch_predictions(self, params: str = None) -> list[MBTAPrediction]:
-        """Retrive MBTA predictions based on the provided stop IDs"""
-        self.logger.debug("Retriving MBTA predictions")
+        """Retrieve MBTA predictions based on the provided stop IDs"""
+        self.logger.debug("Retrieving MBTA predictions")
         base_params = {
             'filter[stop]': ','.join(self._get_stops_ids()),
             'filter[revenue]': 'REVENUE',
@@ -173,17 +185,19 @@ class BaseHandler:
         try:
             predictions: list[MBTAPrediction] = await self.mbta_client.list_predictions(base_params)
             return predictions
+        except aiohttp.ClientError as e:
+            self.logger.error("HTTP error occurred while retrieving MBTA predictions: {}".format(e))
+            return []
         except Exception as e:
-            self.logger.error(f"Error retriving MBTA predictions: {e}")
+            self.logger.error("Error retrieving MBTA predictions: {}".format(e))
 
-          
     async def _process_predictions(self, predictions: list[MBTAPrediction]):
         self.logger.debug("Processing MBTA predictions")
 
         for prediction in predictions:
             # Validate prediction data
             if not prediction.trip_id or not prediction.stop_id:
-                self.logger.error(f"Invalid prediction data: {prediction}")
+                self.logger.error("Invalid prediction data: {}".format(prediction))
                 continue  # Skip to the next prediction
 
             # If the trip of the prediction is not in the journeys dict
@@ -196,7 +210,7 @@ class BaseHandler:
             # Validate stop
             stop = self.__get_stop_by_id(prediction.stop_id)
             if not stop:
-                self.logger.error(f"Invalid stop ID: {prediction.stop_id} for prediction: {prediction}")
+                self.logger.error("Invalid stop ID: {} for prediction: {}".format(prediction.stop_id, prediction))
                 continue  # Skip to the next prediction
 
             departure_stops_ids = self.__get_stops_ids_by_stop_type('departure')
@@ -212,12 +226,11 @@ class BaseHandler:
             elif prediction.stop_id in arrival_stops_ids:
                 self.journeys[prediction.trip_id].add_stop('arrival', prediction, stop, prediction.schedule_relationship)
             else:
-                self.logger.warning(f"Stop ID {prediction.stop_id} is not categorized as departure or arrival for prediction: {prediction}")
-                
+                self.logger.warning("Stop ID {} is not categorized as departure or arrival for prediction: {}".format(prediction.stop_id, prediction))               
 
-    async def _fetch_alerts(self,params: str = None) -> list[MBTAAlert]:
-        """Retrive MBTA alerts"""
-        self.logger.debug("Retriving MBTA alerts")
+    async def _fetch_alerts(self, params: str = None) -> list[MBTAAlert]:
+        """Retrieve MBTA alerts"""
+        self.logger.debug("Retrieving MBTA alerts")
                 
         # Prepare filter parameters
         base_params = {
@@ -232,9 +245,12 @@ class BaseHandler:
         try:
             alerts: list[MBTAAlert] = await self.mbta_client.list_alerts(base_params)
             return alerts
+        except aiohttp.ClientError as e:
+            self.logger.error("HTTP error occurred while retrieving MBTA alerts: {}".format(e))
+            return []
         except Exception as e:
-            self.logger.error(f"Error retriving MBTA alerts: {e}")
-
+            self.logger.error("Error retrieving MBTA alerts: {}".format(e))
+            return []
             
     def _process_alerts(self, alerts: list[MBTAAlert]):
         self.logger.debug("Processing MBTA alerts")
@@ -242,12 +258,12 @@ class BaseHandler:
         for alert in alerts:
             # Validate alert data
             if not alert.id or not alert.effect:
-                self.logger.error(f"Invalid alert data: {alert}")
+                self.logger.error("Invalid alert data: {}".format(alert))
                 continue  # Skip to the next alert
 
             # Iterate through each journey and associate relevant alerts
             for journey in self.journeys.values():
-            # Check if the alert is already associated by comparing IDs
+                # Check if the alert is already associated by comparing IDs
                 if any(existing_alert.id == alert.id for existing_alert in journey.alerts):
                     continue  # Skip if alert is already associated
 
@@ -256,7 +272,7 @@ class BaseHandler:
                     if self.__is_alert_relevant(alert, journey):
                         journey.alerts.append(alert)
                 except Exception as e:
-                    self.logger.error(f"Error processing MBTA alert {alert.id}: {e}")
+                    self.logger.error("Error processing MBTA alert {}: {}".format(alert.id, e))
                     continue  # Skip to the next journey if an error occurs
 
     def __is_alert_relevant(self, alert: MBTAAlert, journey: Journey) -> bool:
@@ -291,36 +307,44 @@ class BaseHandler:
     @memoize_async()
     async def _fetch_trip(self, trip_id: str, params: dict = None) -> Optional[MBTATrip]:
         """Retrieve MBTA trip based on trip_id."""
-        self.logger.debug(f"Retriving MBTA trip: {trip_id} ")
+        self.logger.debug("Retrieving MBTA trip: {}".format(trip_id))
         try:
             trip: MBTATrip = await self.mbta_client.get_trip(trip_id, params)
             return trip
+        except aiohttp.ClientError as e:
+            self.logger.error("HTTP error occurred while fetching trip {}: {}".format(trip_id, e))
+            return None
         except Exception as e:
-            self.logger.error(f"Error fetching trip {trip_id}: {e}")
+            self.logger.error("Error fetching trip {}: {}".format(trip_id, e))
             return None
     
     @memoize_async()
     async def _fetch_route(self, route_id: str, params: dict = None) -> Optional[MBTARoute]:
-        """Retrive MBTA route based on route_id."""
-        self.logger.debug(f"Retriving MBTA route: {route_id} ")
+        """Retrieve MBTA route based on route_id."""
+        self.logger.debug("Retrieving MBTA route: {}".format(route_id))
         try:
             route: MBTARoute = await self.mbta_client.get_route(route_id, params)
             return route
+        except aiohttp.ClientError as e:
+            self.logger.error("HTTP error occurred while retrieving MBTA route {}: {}".format(route_id, e))
+            return None
         except Exception as e:
-            self.logger.error(f"Error retriving MBTA route {route_id}: {e}")
+            self.logger.error("Error retrieving MBTA route {}: {}".format(route_id, e))
             return None
     
     @memoize_async()
     async def _fetch_trips(self, params: dict = None) -> Optional[MBTARoute]:
-        """Retrive MBTA trips"""
-        self.logger.debug("Retriving MBTA trips")
+        """Retrieve MBTA trips"""
+        self.logger.debug("Retrieving MBTA trips")
         try:
             trips: list[MBTATrip] = await self.mbta_client.list_trips(params)
             return trips
+        except aiohttp.ClientError as e:
+            self.logger.error("HTTP error occurred while retrieving MBTA trips: {}".format(e))
+            return None
         except Exception as e:
-            self.logger.error(f"Error retriving MBTA route: {e}")
+            self.logger.error("Error retrieving MBTA trips: {}".format(e))
             return None
-        
 
 class MBTAStopError(Exception):
     pass

{mbtaclient-0.2.6 → mbtaclient-0.2.8}/src/mbtaclient/journey_stop.py

@@ -50,7 +50,7 @@ class JourneyStop:
                 self.real_departure_time = MBTAUtils.parse_datetime(departure_time)
                 if self.departure_time is not None:
                     self.departure_delay = MBTAUtils.calculate_time_difference(self.real_departure_time, self.departure_time)
-
+            
     def get_time(self) -> Optional[datetime]:
         """Return the most relevant time for the stop."""
         if self.real_arrival_time is not None:

mbtaclient-0.2.8/src/mbtaclient/journeys_handler.py

@@ -0,0 +1,108 @@
+import aiohttp
+import logging
+from datetime import datetime
+
+from .base_handler import BaseHandler
+from .journey import Journey
+from .mbta_route import MBTARoute
+from .mbta_trip import MBTATrip
+from .mbta_schedule import MBTASchedule
+
+
+class JourneysHandler(BaseHandler):
+    """Handler for managing a specific journey."""
+
+    def __init__(self, depart_from_name: str, arrive_at_name: str, max_journeys: int = 4, api_key: str = None, session: aiohttp.ClientSession = None, logger: logging.Logger = None):
+        super().__init__(depart_from_name=depart_from_name, arrive_at_name=arrive_at_name, api_key=api_key, session=session, logger=logger) 
+        self.max_journeys = max_journeys
+        self.logger: logging.Logger = logger or logging.getLogger(__name__)
+            
+    async def async_init(self):
+        try:
+            await super()._async_init()
+        except Exception as e:
+            self.logger.error("Error during async initialization: {}".format(e))
+            raise
+    
+    async def update(self) -> list[Journey]:
+        try:
+            schedules = await self.__fetch_schedules()
+            await super()._process_schedules(schedules)
+            
+            predictions = await self._fetch_predictions()
+            await super()._process_predictions(predictions)
+            
+            self.__sort_and_clean()
+            
+            await self.__fetch_trips()
+            
+            await self.__fetch_routes()
+            
+            alerts = await self._fetch_alerts()
+            super()._process_alerts(alerts)  
+            
+            return list(self.journeys.values())
+        except Exception as e:
+            self.logger.error("Error during update: {}".format(e))
+            raise
+    
+    async def __fetch_schedules(self) -> list[MBTASchedule]:
+        try:
+            now = datetime.now().astimezone()
+            
+            params = {
+                'filter[stop]': ','.join(super()._get_stops_ids()),
+                'filter[min_time]': now.strftime('%H:%M'),
+            }
+            
+            schedules = await super()._fetch_schedules(params)
+            return schedules
+        except Exception as e:
+            self.logger.error("Error fetching schedules: {}".format(e))
+            raise
+    
+    def __sort_and_clean(self):
+        try:
+            now = datetime.now().astimezone()
+            
+            processed_journeys = {
+                trip_id: journey
+                for trip_id, journey in self.journeys.items()
+                if journey.stops['departure'] 
+                and journey.stops['arrival'] 
+                and journey.stops['departure'].stop_sequence < journey.stops['arrival'].stop_sequence
+                #and journey.stops['departure'].get_time() is not None 
+                and journey.stops['departure'].get_time() >= now
+            }
+
+            sorted_journeys = dict(
+                sorted(
+                    processed_journeys.items(),
+                    key=lambda item: item[1].stops['departure'].get_time()
+                )
+            )
+
+            self.journeys = dict(list(sorted_journeys.items())[:self.max_journeys] if self.max_journeys > 0 else sorted_journeys)
+        
+        except Exception as e:
+            self.logger.error("Error sorting and cleaning journeys: {}".format(e))
+            raise
+
+    async def __fetch_trips(self):
+        try:
+            for trip_id, journey in self.journeys.items():
+                trip: MBTATrip = await super()._fetch_trip(trip_id)
+                journey.trip = trip
+        except Exception as e:
+            self.logger.error("Error fetching trips: {}".format(e))
+            raise
+
+    async def __fetch_routes(self):
+        try:
+            for journey in self.journeys.values():
+                if journey.trip and journey.trip.route_id:
+                    route: MBTARoute = await super()._fetch_route(journey.trip.route_id)
+                    journey.route = route
+        except Exception as e:
+            self.logger.error("Error fetching routes: {}".format(e))
+            raise

{mbtaclient-0.2.6 → mbtaclient-0.2.8}/src/mbtaclient/mbta_client.py

@@ -29,6 +29,18 @@ class MBTAClient:
         self.logger: logging.Logger = logger or logging.getLogger(__name__)
         self._api_key: str = api_key 
     
+    async def __aenter__(self):
+        """Enter the context and return the client."""
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        """Exit the context and close the session."""
+        await self.close()
+    
+    async def close(self) -> None:
+        """Close the session manually."""
+        await self._session.close()
+        
     async def get_route(self, id: str, params: Optional[dict[str, Any]] = None) -> MBTARoute:
         """Get a route by its ID."""
         route_data = await self._fetch_data(f'{ENDPOINTS["ROUTES"]}/{id}', params)
@@ -80,12 +92,12 @@ class MBTAClient:
             response = await self.request("get", endpoint, params)
             data = await response.json() 
             if 'data' not in data:
-                raise ValueError("Unexpected response format")
+                raise ValueError("missing 'data'")
             return data
         except Exception as error:
             self.logger.error(f"Error fetching data: {error}")
             raise
-        
+            
     async def request(
         self, method: str, path: str, params: Optional[dict[str, Any]] = None) -> aiohttp.ClientResponse:
         """Make an HTTP request with Optional query parameters and JSON body."""

{mbtaclient-0.2.6 → mbtaclient-0.2.8}/src/mbtaclient/mbta_utils.py

@@ -1,12 +1,9 @@
 from datetime import datetime, timedelta
-
 from typing import Optional
-from collections.abc import Hashable
 import logging
 
 # logging.basicConfig(level=logging.DEBUG)
-_LOGGER = logging.getLogger(__name__)
-
+logger = logging.getLogger(__name__)
 
 class MBTAUtils:
         
@@ -40,7 +37,18 @@ class MBTAUtils:
     @staticmethod
     def time_to(time: Optional[datetime], now: datetime) -> Optional[float]:
         if time is None:
+            logger.warning("time_to: Provided 'time' is None.")
             return None
+        # Check if both datetime objects have timezone info
+        if time.tzinfo != now.tzinfo:
+            # Make both datetimes the same type: either both naive or both aware
+            if time.tzinfo is None and now.tzinfo is not None:
+                # Convert time to aware by using the timezone of `now`
+                time = time.replace(tzinfo=now.tzinfo)
+            elif time.tzinfo is not None and now.tzinfo is None:
+                # Convert now to naive by stripping timezone info
+                now = now.replace(tzinfo=None)
+        # Now perform the calculation
         return (time - now).total_seconds()
 
     @staticmethod
@@ -54,8 +62,11 @@ class MBTAUtils:
         """Parse a string in ISO 8601 format to a datetime object."""
         if not isinstance(time_str, str):
             return None
-        return datetime.fromisoformat(time_str)
-    
+        try:
+            return datetime.fromisoformat(time_str)
+        except ValueError as e:
+            logger.error(f"Error parsing datetime string: {e}")
+            return None
 
 
 from datetime import datetime, timedelta
@@ -83,18 +94,22 @@ def memoize_async(expire_at_end_of_day=False):
 
                 if expire_at_end_of_day:
                     if timestamp.date() == current_time.date():
-                        _LOGGER.debug(f"Cache hit for {func.__name__} with arguments {cache_key} at {current_time}")
+                        logger.debug(f"Cache hit for {func.__name__} with arguments {cache_key} at {current_time}")
                         return cached_result
                 else:  # Expiration based on 30 days
                     if current_time - timestamp < timedelta(days=30):
-                        _LOGGER.debug(f"Cache hit for {func.__name__} with arguments {cache_key} at {current_time}")
+                        logger.debug(f"Cache hit for {func.__name__} with arguments {cache_key} at {current_time}")
                         return cached_result
 
-            _LOGGER.debug(f"Cache miss for {func.__name__} with arguments {cache_key} at {current_time}")
-            result = await func(*args)
+            logger.debug(f"Cache miss for {func.__name__} with arguments {cache_key} at {current_time}")
+            try:
+                result = await func(*args)
+            except Exception as e:
+                logger.error(f"Error occurred while executing {func.__name__} with arguments {args}: {e}")
+                raise
             cache[cache_key] = (result, current_time)
-            _LOGGER.debug(f"Cache updated for key: {cache_key} at {current_time}")
+            logger.debug(f"Cache updated for key: {cache_key} at {current_time}")
             return result
 
         return wrapper
-    return decorator
+    return decorator