MBTAclient 0.2.6__tar.gz → 0.2.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MBTAclient
-Version: 0.2.6
+Version: 0.2.7
 Summary: A Python client for interacting with the MBTA API
 Author-email: Luca Chiabrera <luca.chiabrera@gmail.com>
 License: MIT

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MBTAclient"
-version = "0.2.6"
+version = "0.2.7"
 description = "A Python client for interacting with the MBTA API"
 readme = "README.md"
 requires-python = ">=3.12"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MBTAclient
-Version: 0.2.6
+Version: 0.2.7
 Summary: A Python client for interacting with the MBTA API
 Author-email: Luca Chiabrera <luca.chiabrera@gmail.com>
 License: MIT

{mbtaclient-0.2.6 → mbtaclient-0.2.7}/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.7/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.7}/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)

{mbtaclient-0.2.6 → mbtaclient-0.2.7}/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,6 +37,7 @@ 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
         return (time - now).total_seconds()
 
@@ -54,8 +52,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 +84,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

mbtaclient-0.2.7/src/mbtaclient/trip_handler.py

@@ -0,0 +1,115 @@
+import aiohttp
+import logging
+
+from datetime import datetime, timedelta
+from .base_handler import BaseHandler, MBTATripError
+from .journey import Journey
+from .mbta_route import MBTARoute
+from .mbta_trip import MBTATrip
+from .mbta_schedule import MBTASchedule
+
+class TripHandler(BaseHandler):
+    """Handler for managing a specific trip."""
+
+    def __init__(self, depart_from_name: str, arrive_at_name: str, trip_name: str, 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.trip_name = trip_name
+        self.logger: logging.Logger = logger or logging.getLogger(__name__)
+            
+    async def async_init(self):
+        self.logger.debug("Initializing TripHandler")
+        try:
+            await super()._async_init()
+
+            self.logger.debug("Retrieving MBTA trip for {}".format(self.trip_name))
+            params = {
+                'filter[revenue]': 'REVENUE',
+                'filter[name]': self.trip_name
+            }
+            
+            # Fetch trips and validate the response
+            trips: list[MBTATrip] = await super()._fetch_trips(params)
+            if not trips or not isinstance(trips, list) or not trips[0]:
+                self.logger.error("Error retrieving MBTA trip {}: Invalid trip name or response".format(self.trip_name))
+                raise MBTATripError("Invalid trip name")
+
+            # Create a new journey and assign the first trip
+            journey = Journey()
+            journey.trip = trips[0]
+            
+            self.logger.debug("Retrieving MBTA route for trip {}".format(self.trip_name))
+            route: MBTARoute = await super()._fetch_route(journey.trip.route_id)
+            if route is None:
+                self.logger.error("Error retrieving MBTA route for trip {}".format(self.trip_name))
+                raise MBTATripError("Invalid route")
+
+            journey.route = route
+            self.journeys[trips[0].id] = journey
+            self.logger.info("Trip {} initialized successfully with route {}".format(self.trip_name, journey.route.id))
+            
+        except Exception as e:
+            self.logger.error("Error during TripHandler initialization: {}".format(e))
+    
+    async def update(self) -> list[Journey]:
+        now = datetime.now().astimezone()
+        self.logger.debug("Updating trips for {}".format(self.trip_name))
+        
+        try:
+            for i in range(7):
+                params = {}
+                date_to_try = (now + timedelta(days=i)).strftime('%Y-%m-%d')
+                params['filter[date]'] = date_to_try
+                if i == 0:
+                    params['filter[min_time]'] = now.strftime('%H:%M')
+                
+                self.logger.debug("Fetching schedules for {} for trip {}".format(date_to_try, self.trip_name))
+                schedules = await self.__fetch_schedules(params)
+                await super()._process_schedules(schedules)
+                
+                # Check for valid schedules
+                if next(iter(self.journeys.values())).get_stop_time_to('arrival') is not None:
+                    self.logger.info("Valid schedule found for trip {} on {}".format(self.trip_name, date_to_try))
+                    break
+
+                # Log an error if no valid schedules after the final attempt
+                if i == 6:
+                    self.logger.error("Error retrieving scheduling for {} and {} on trip {}".format(self.depart_from['name'], self.arrive_at['name'], self.trip_name))
+                    raise MBTATripError("Invalid stops for the trip")
+                
+        except MBTATripError as e:
+            self.logger.error("{}".format(e))
+        
+        # Fetch predictions and alerts
+        try:
+            self.logger.debug("Fetching predictions for trip {}".format(self.trip_name))
+            predictions = await self.__fetch_predictions()
+            await super()._process_predictions(predictions)
+        
+            self.logger.debug("Fetching alerts for trip {}".format(self.trip_name))
+            alerts = await self.__fetch_alerts()
+            super()._process_alerts(alerts)  
+        
+        except Exception as e:
+            self.logger.error("Error during predictions/alerts fetching for trip {}: {}".format(self.trip_name, e))
+        
+        return list(self.journeys.values())
+    
+    
+    async def __fetch_schedules(self, params: dict) -> list[MBTASchedule]:
+        self.logger.debug("Fetching schedules with params: {}".format(params))
+        journey = next(iter(self.journeys.values()))
+        trip_id = journey.trip.id
+
+        base_params = {
+            'filter[trip]': trip_id,
+        }
+        if params is not None:
+            base_params.update(params)
+        
+        try:
+            schedules = await super()._fetch_schedules(base_params)
+            self.logger.debug("Fetched {} schedules for trip {}".format(len(schedules), trip_id))
+            return schedules
+        except Exception as e:
+            self.logger.error("Error fetching schedules for trip {}: {}".format(trip_id, e))
+  

mbtaclient-0.2.6/src/mbtaclient/journeys_handler.py

@@ -1,89 +0,0 @@
-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, 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
-    
-    async def async_init(self):
-        await super()._async_init()
-        
-    async def update(self) -> list[Journey]:
-       
-        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())
-    
-    async def __fetch_schedules(self) -> list[MBTASchedule]:
-        
-        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
-    
-    def __sort_and_clean(self):
-        """Clean up and sort valid journeys."""
-        
-        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()  >= 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)
-
-    async def __fetch_trips(self):
-        """Retrieve trip details for each journey."""
-        for trip_id, journey in self.journeys.items():
-            trip: MBTATrip = await super()._fetch_trip(trip_id)
-            journey.trip = trip
-
-    async def __fetch_routes(self):
-        """Retrieve route details for each journey."""
-        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              

mbtaclient-0.2.6/src/mbtaclient/trip_handler.py

@@ -1,124 +0,0 @@
-import aiohttp
-import logging
-
-from datetime import datetime, timedelta
-from .base_handler import BaseHandler, MBTATripError
-from .journey import Journey
-from .mbta_route import MBTARoute
-from .mbta_trip import MBTATrip
-from .mbta_schedule import MBTASchedule
-from .mbta_prediction import MBTAPrediction
-
-class TripHandler(BaseHandler):
-    """Handler for managing a specific trip."""
-
-    def __init__(self, depart_from_name: str, arrive_at_name: str, trip_name: str, 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.trip_name = trip_name
-        
-            
-    async def async_init(self):
-        self.logger.debug("Initializing TripHandler")
-        try:
-            await super()._async_init()
-
-            self.logger.debug("Retriving MBTA trip")
-            params = {
-                'filter[revenue]': 'REVENUE',
-                'filter[name]': self.trip_name
-            }
-            
-            # Fetch trips and validate the response
-            trips: list[MBTATrip] = await super()._fetch_trips(params)
-            if not trips or not isinstance(trips, list) or not trips[0]:
-                self.logger.error(f"Error retriving MBTA trip {self.trip_name}")
-                raise MBTATripError("Invalid trip name")                
-
-            
-            # Create a new journey and assign the first trip
-            journey = Journey()
-            journey.trip = trips[0]
-            
-            # Fetch route and validate the response
-            self.logger.debug("Retriving MBTA route")
-            route: MBTARoute = await super()._fetch_route(journey.trip.route_id)
-
-            journey.route = route
-            self.journeys[trips[0].id] = journey
-
-        except Exception as e:
-            self.logger.error(f"Error during TripHandler initialization: {e}")
-    
-    async def update(self) -> list[Journey]:
-        now = datetime.now().astimezone()
-
-        try:
-            for i in range(7):
-                params = {}
-                # Calculate the date for each attempt (i days after today)
-                date_to_try = (now + timedelta(days=i)).strftime('%Y-%m-%d')
-                params['filter[date]'] = date_to_try
-                if i == 0:
-                    params['filter[min_time]'] = now.strftime('%H:%M')
-                
-                # Attempt to get schedules for up to the next 7 days
-                schedules = await self.__fetch_schedules(params)
-                await super()._process_schedules(schedules)
-                if next(iter(self.journeys.values())).get_stop_time_to('arrival') is not None:
-                    break
-                
-                # If it's the last attempt and no valid schedules were found, log an error and raise an exception
-                if i == 6:
-                    self.logger.error(
-                        f"Error retrieving scheduling for {self.depart_from['name']} and {self.arrive_at['name']} on trip {self.trip_name}"
-                    )
-                    raise MBTATripError("Invalid stops for the trip")
-                
-        except MBTATripError as e:
-            # Handle the error here without re-raising it
-            self.logger.error(f"{e}")
-            # Continue with other operations despite the failure
-                   
-        predictions = await self.__fetch_predictions()
-        await super()._process_predictions(predictions)
-        
-        alerts = await self.__fetch_alerts()
-        super()._process_alerts(alerts)  
-        return  list(self.journeys.values())
-    
-    
-    async def __fetch_schedules(self, params: dict) -> list[MBTASchedule]:
-        journey = next(iter(self.journeys.values()))
-        trip_id = journey.trip.id
-      
-
-        base_params = {
-            'filter[trip]': trip_id,
-        }
-        if params is not None:
-            base_params.update(params)
- 
-        schedules = await super()._fetch_schedules(base_params)
-        return schedules
-
-
-    async def __fetch_predictions(self) -> list[MBTAPrediction]:
-        jounrey = next(iter(self.journeys.values()))
-        jounrey.trip.id
-        params = {
-            'filter[trip]':  jounrey.trip.id,
-        } 
-        predictions = await super()._fetch_predictions(params)
-        return predictions                   
-
-
-    async def __fetch_alerts(self) -> list[MBTAPrediction]:
-        jounrey = next(iter(self.journeys.values()))
-        jounrey.trip.id
-        params = {
-            'filter[trip]':  jounrey.trip.id,
-        }
-        alerts = await super()._fetch_alerts(params)
-        return alerts 
-    
-