MBTAclient 0.2.0__tar.gz → 0.2.1__tar.gz

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MBTAclient
-Version: 0.2.0
+Version: 0.2.1
 Summary: A Python client for interacting with the MBTA API
 Author-email: Luca Chiabrera <luca.chiabrera@gmail.com>
 Project-URL: Homepage, https://github.com/chiabre/MBTAclient

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "MBTAclient"
-version = "0.2.0"
+version = "0.2.1"
 authors = [
   { name="Luca Chiabrera", email="luca.chiabrera@gmail.com" },
 ]

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/MBTAclient.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MBTAclient
-Version: 0.2.0
+Version: 0.2.1
 Summary: A Python client for interacting with the MBTA API
 Author-email: Luca Chiabrera <luca.chiabrera@gmail.com>
 Project-URL: Homepage, https://github.com/chiabre/MBTAclient

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/base_handler.py

@@ -17,14 +17,22 @@ from mbta_alert import MBTAAlert
 
 
 class BaseHandler:
-    """Base class for handling MBTA data."""
+    """Base class for handling MBTA journeys."""
     
-    def __init__(self, session: aiohttp.ClientSession, api_key: str, depart_from_name: str , arrive_at_name: str) -> None:
-
+    def __init__(self, session: aiohttp.ClientSession, logger: logging.Logger, depart_from_name: str , arrive_at_name: str, api_key: str = None) -> None:
     
-        self.mbta_client = MBTAClient(session, api_key)
-        self.depart_from_name = depart_from_name
-        self.arrive_at_name = arrive_at_name
+        self.depart_from = {
+            'name' : depart_from_name,
+            'stops' : None,
+            'ids' : None
+        }
+        self.arrive_at = {
+            'name' : arrive_at_name,
+            'stops' : None,
+            'ids' : None
+        }
+        self.mbta_client = MBTAClient(session,logger, api_key=api_key)
+
         self.journeys: dict[str, Journey] = {} 
   
         # Caches 
@@ -33,14 +41,24 @@ class BaseHandler:
         self._schedules_cache_date: Optional[date] = None
         self._trip_cache: dict[str, MBTATrip] = {}
         self._route_cache: dict[str, MBTARoute] = {}
-        self._stop_name_cache: dict[str, list[MBTAStop]] = {}
+        
+        # Logger
+        self.logger: logging.Logger = logger
+ 
+    def __repr__(self) -> str:
+        return (f"BaseHandler(depart_from_name={self.depart_from['name']}, arrive_at_name={self.arrive_at['name']})")
+ 
+        
+    async def _async_init(self):
+        stops = await self.__fetch_stops()
+        self.__process_stops(stops)
     
-    async def _fetch_stops(self, params: dict = None) -> list[MBTAStop]:
+    async def __fetch_stops(self, params: dict = None) -> list[MBTAStop]:
         """Retrieve and process stops with a non-expiring cache."""
+        self.logger.debug("Fetching MBTA stops")
         
         # Check if stops are already cached
         if self._stops_cache is not None:
-            logging.info("Returning cached stops")
             return self._stops_cache
 
         # Cache is empty, so we fetch the stops from the API
@@ -51,70 +69,68 @@ class BaseHandler:
         
         try:
             stops: list[MBTAStop] = await self.mbta_client.list_stops(base_params)
-            # Update the cache
+            self.logger.debug("Updating cached stops")
             self._stops_cache = stops
             return stops
         
         except Exception as e:
-            logging.error(f"Error fetching stops: {e}")
+            self.logger.error(f"Error fetching stops: {e}")
             traceback.print_exc()
             return []
-
-    async def _get_stops_ids(self)  -> list[str]:
-        departure_stop_ids = await self.__get_stops_ids_by_name(self.depart_from_name)
-        arrival_stop_ids = await self.__get_stops_ids_by_name(self.arrive_at_name)
-        return departure_stop_ids + arrival_stop_ids                
-
-    async def __get_stops_ids_by_name(self, stop_name: str ) -> list[str]:
-        stops = await self.__get_stops_by_name(stop_name)
-        stop_ids = [stop.id for stop in stops]
-        return stop_ids
-                      
-    async def _get_stops(self)  -> list['MBTAStop']:
-        departure_stops = await self.__get_stops_by_name(self.depart_from_name)
-        arrival_stops = await self.__get_stops_by_name(self.arrive_at_name)
-        return departure_stops + arrival_stops     
-      
-    async def __get_stops_by_name(self, stop_name: str) -> list[MBTAStop]:
-        # Check if the stops for the stop_name are already cached
-        if stop_name.lower() in self._stop_name_cache:
-            logging.info(f"Returning cached stops for stop_name: {stop_name}")
-            return self._stop_name_cache[stop_name.lower()]
-
-        # Fetch all stops (assuming _fetch_stops is asynchronous)
-        stops = await self._fetch_stops()
-
-        # Filter stops by the given name
-        matching_stops = [stop for stop in stops if stop.name.lower() == stop_name.lower()]
-
-        # Cache the result
-        self._stop_name_cache[stop_name.lower()] = matching_stops
-
-        return matching_stops
-    
-    async def _get_stop_by_id(self, stop_id: str) -> MBTAStop:
-
-        # Fetch all stops (assuming _fetch_stops is asynchronous)
-        stops = await self._fetch_stops()
-
-        # Find the first stop that matches the given stop_id
+        
+    def  __process_stops(self, stops: list[MBTAStop]):
+        depart_from_stops = []
+        depart_from_ids = []
+        arrive_at_stops = []
+        arrive_at_ids = []
         for stop in stops:
+            if stop.name.lower() == self.depart_from['name'].lower():
+                depart_from_stops.append(stop)
+                depart_from_ids.append(stop.id)
+            if stop.name.lower() == self.arrive_at['name'].lower():
+                arrive_at_stops.append(stop)
+                arrive_at_ids.append(stop.id)
+                
+        if len(depart_from_stops) == 0:
+            self.logger.error(f"Error fetching MBTA stop data for {self.depart_from['name']}")
+            raise ValueError(f"Invalid stop name: {self.depart_from['name']}")
+        
+        if len(arrive_at_stops) == 0:
+            self.logger.error(f"Error fetching MBTA stop data for {self.arrive_at['name']}")
+            raise ValueError(f"Invalid stop name: {self.arrive_at['name']}")
+        else:    
+            self.depart_from['stops'] = depart_from_stops
+            self.depart_from['ids'] = depart_from_ids
+            self.arrive_at['stops'] = arrive_at_stops
+            self.arrive_at['ids'] = arrive_at_ids
+
+    def __get_stop_by_id(self, stop_id: str) -> Optional[MBTAStop]:
+        for stop in (self.depart_from['stops'] + self.arrive_at['stops']):
             if stop.id == stop_id:
                 return stop
-
-        # Return None if no matching stop is found
         return None
-                    
+    
+    def _get_stops_ids(self) -> list[str]:
+        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           
+    
     async def _fetch_schedules(self, params: Optional[dict] = None) -> list[MBTASchedule]:
         """Retrieve and process schedules for today."""
-
+        self.logger.debug("Fetching MBTA schedules")
+        
         # Check if the cache is outdated
         if self._schedules_cache_date is not None and self._schedules_cache_date == date.today():
-            logging.info("Returning cached schedules")
+            self.logger.debug("Returning cached schedules")
             return self._schedules_cache
 
         base_params = {
-            'filter[stop]': ','.join(await self._get_stops_ids()),
+            'filter[stop]': ','.join(self._get_stops_ids()),
             'sort': 'departure_time'
         }
         if params is not None:
@@ -123,15 +139,17 @@ class BaseHandler:
         try:
             schedules: list[MBTASchedule] = await self.mbta_client.list_schedules(base_params)
             # Update the cache with new data and timestamp
+            self.logger.debug("Updating cached schedules")
             self._schedules_cache = schedules
             self._schedules_cache_date = date.today()
             return schedules
         except Exception as e:
-            logging.error(f"Error fetching schedules: {e}")
+            self.logger.error(f"Error fetching schedules: {e}")
             traceback.print_exc()
             return []
             
     async def _process_schedules(self, schedules: list[MBTASchedule]):
+        self.logger.debug("Processing schedules")
               
         for schedule in schedules:               
             
@@ -142,21 +160,22 @@ class BaseHandler:
                 # add the journey to the journeys dict using the trip_id as key
                 self.journeys[schedule.trip_id] = journey
                 
-            stop: MBTAStop = await self._get_stop_by_id(schedule.stop_id) 
-            departure_stop_ids = await self.__get_stops_ids_by_name(self.depart_from_name)    
-            arrival_stop_id = await self.__get_stops_ids_by_name(self.arrive_at_name)          
+            stop: MBTAStop = self.__get_stop_by_id(schedule.stop_id)
+            departure_stops_ids = self.__get_stops_ids_by_stop_type('departure')
+            arrival_stops_ids = self.__get_stops_ids_by_stop_type('arrival')
             
-            if schedule.stop_id in departure_stop_ids:
+            if schedule.stop_id in departure_stops_ids:
                 self.journeys[schedule.trip_id].add_stop('departure',schedule,stop,'SCHEDULED')
-            elif schedule.stop_id in arrival_stop_id:
+            elif schedule.stop_id in arrival_stops_ids:
                 self.journeys[schedule.trip_id].add_stop('arrival',schedule, stop,'SCHEDULED')
     
 
     async def _fetch_predictions(self, params: str = None) -> list[MBTAPrediction]:
         """Retrieve and process predictions based on the provided stop IDs and route ID."""
-
+        self.logger.debug("Fetching MBTA predictions")
+                
         base_params = {
-            'filter[stop]': ','.join(await self._get_stops_ids()),
+            'filter[stop]': ','.join(self._get_stops_ids()),
             'filter[revenue]': 'REVENUE',
             'sort': 'departure_time'
         }
@@ -169,11 +188,12 @@ class BaseHandler:
             return predictions
         
         except Exception as e:
-            logging.error(f"Error fetching predictions: {e}")
+            self.logger.error(f"Error fetching predictions: {e}")
             traceback.print_exc()
           
     async def _process_predictions (self, predictions: list[MBTAPrediction]):   
-        
+        self.logger.debug("Processing predictions")
+                
         for prediction in predictions:
         
             # if the trip of the prediciton is not in the journeys dict
@@ -183,29 +203,27 @@ class BaseHandler:
                 # add the journey to the journeys dict using the trip_id as key
                 self.journeys[prediction.trip_id] = journey
                 
-            stop: MBTAStop = await self._get_stop_by_id(prediction.stop_id)
-            departure_stop_ids = await self.__get_stops_ids_by_name(self.depart_from_name)    
-            arrival_stop_id = await self.__get_stops_ids_by_name(self.arrive_at_name)     
+            stop: MBTAStop = self.__get_stop_by_id(prediction.stop_id)
+            departure_stops_ids = self.__get_stops_ids_by_stop_type('departure')
+            arrival_stops_ids = self.__get_stops_ids_by_stop_type('arrival')
                         
             if prediction.schedule_relationship is None:
-                prediction.schedule_relationship = 'DELAYED'   
+                prediction.schedule_relationship = 'PREDICTED'   
             
             # if the prediction stop id is in the departure stop ids
-            if prediction.stop_id in departure_stop_ids:
-        
+            if prediction.stop_id in departure_stops_ids:
                 self.journeys[prediction.trip_id].add_stop('departure',prediction,stop,prediction.schedule_relationship)
-                        
             # if the prediction stop id is in the arrival stop ids 
-            if prediction.stop_id in arrival_stop_id:
-
+            if prediction.stop_id in arrival_stops_ids:
                 self.journeys[prediction.trip_id].add_stop('arrival',prediction,stop,prediction.schedule_relationship)
 
     async def _fetch_alerts(self,params: str = None) -> list[MBTAAlert]:
         """Retrieve and associate alerts with the relevant journeys."""
-        
+        self.logger.debug("Fetching MBTA alerts")
+                
         # Prepare filter parameters
         base_params = {
-            'filter[stop]': ','.join(await self._get_stops_ids()),
+            'filter[stop]': ','.join(self._get_stops_ids()),
             'filter[activity]': 'BOARD,EXIT,RIDE',
             'filter[datetime]': 'NOW'
         }
@@ -217,23 +235,24 @@ class BaseHandler:
             alerts: list[MBTAAlert] = await self.mbta_client.list_alerts(base_params)
             return alerts
         except Exception as e:
-            logging.error(f"Error fetching alerts: {e}")
+            self.logger.error(f"Error fetching alerts: {e}")
             traceback.print_exc()
             
     def _process_alerts(self, alerts: list[MBTAAlert]):
+        self.logger.debug("Processing alerts")
         
-            for alert in alerts:
-                
-                # Iterate through each journey and associate relevant alerts
-                for journey in self.journeys.values():
-                    if alert in journey.alerts:
-                        continue  # Skip if alert is already associated
+        for alert in alerts:
+            
+            # Iterate through each journey and associate relevant alerts
+            for journey in self.journeys.values():
+                if alert in journey.alerts:
+                    continue  # Skip if alert is already associated
 
-                    # Check if the alert is relevant to the journey
-                    if self._is_alert_relevant(alert, journey):
-                        journey.alerts.append(alert)
+                # Check if the alert is relevant to the journey
+                if self.__is_alert_relevant(alert, journey):
+                    journey.alerts.append(alert)
 
-    def _is_alert_relevant(self, alert: MBTAAlert, journey: Journey) -> bool:
+    def __is_alert_relevant(self, alert: MBTAAlert, journey: Journey) -> bool:
         """Check if an alert is relevant to a given journey."""
         for informed_entity in alert.informed_entities:
             # Check informed entity stop relevance
@@ -246,12 +265,12 @@ class BaseHandler:
             if informed_entity.get('route') and informed_entity['route'] != journey.route.id:
                 continue
             # Check activities relevance based on departure or arrival
-            if not self._is_alert_activity_relevant(informed_entity, journey):
+            if not self.__is_alert_activity_relevant(informed_entity, journey):
                 continue
             return True  # Alert is relevant if all checks pass
         return False  # Alert is not relevant
 
-    def _is_alert_activity_relevant(self, informed_entity: dict, journey: Journey) -> bool:
+    def __is_alert_activity_relevant(self, informed_entity: dict, journey: Journey) -> bool:
         """Check if the activities of the informed entity are relevant to the journey."""
         departure_stop_id = journey.get_stop_id('departure')
         arrival_stop_id = journey.get_stop_id('arrival')
@@ -262,42 +281,55 @@ class BaseHandler:
             return False
         return True
     
-    async def _fetch_trip(self, trip_id: str, params: dict = None) -> MBTATrip:
+    async def _fetch_trip(self, trip_id: str, params: dict = None) -> Optional[MBTATrip]:
         """Retrieve and process a trip with a non-expiring cache based on trip_id."""
+        self.logger.debug(f"Fetching MBTA trip: {trip_id} ")
         
         # Check if the trip is already cached
         if trip_id in self._trip_cache:
-            logging.info(f"Returning cached trip for trip_id: {trip_id}")
+            self.logger.debug(f"Returning cached trip: {trip_id}")
             return self._trip_cache[trip_id]
         
         # Trip is not in the cache, so fetch it from the API
         try:
             trip: MBTATrip = await self.mbta_client.get_trip(trip_id, params)
-            # Update the cache
+            self.logger.debug(f"Updating cached trip: {trip_id}")
             self._trip_cache[trip_id] = trip
             return trip
         
         except Exception as e:
-            logging.error(f"Error fetching trip: {e}")
+            self.logger.error(f"Error fetching trip: {e}")
             traceback.print_exc()
             return None
         
-    async def _fetch_route(self, route_id: str, params: dict = None) -> MBTARoute:
+    async def _fetch_route(self, route_id: str, params: dict = None) -> Optional[MBTARoute]:
         """Retrieve and process a route with a non-expiring cache based on route_id."""
+        self.logger.debug(f"Fetching MBTA route: {route_id} ")
         
         # Check if the trip is already cached
         if route_id in self._route_cache:
-            logging.info(f"Returning cached trip for route_id: {route_id}")
             return self._route_cache[route_id]
         
         # Trip is not in the cache, so fetch it from the API
         try:
             route: MBTARoute = await self.mbta_client.get_route(route_id, params)
             # Update the cache
+            self.logger.debug(f"Updating cached route: {route_id}")
             self._route_cache[route_id] = route
             return route
         
         except Exception as e:
-            logging.error(f"Error fetching route: {e}")
+            self.logger.error(f"Error fetching route: {e}")
             traceback.print_exc()
-            return None
+            return None
+        
+    async def _fetch_trips(self, params: dict = None) -> Optional[MBTARoute]:
+        self.logger.debug("Fetching MBTA trips")
+        try:
+            trips: list[MBTATrip] = await self.mbta_client.list_trips(params)
+            return trips
+        except Exception as e:
+            self.logger.error(f"Error fetching route: {e}")
+            traceback.print_exc()
+            return None
+        

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/journey.py

@@ -1,11 +1,14 @@
-from typing import Optional
+from typing import Union, Optional
 from datetime import datetime
 
 from journey_stop import JourneyStop
+from mbta_schedule import MBTASchedule
+from mbta_prediction import MBTAPrediction
 from mbta_stop import MBTAStop
 from mbta_route import MBTARoute
 from mbta_trip import MBTATrip
 from mbta_alert import MBTAAlert
+from mbta_utils import MBTAUtils
 
 class Journey:
     """A class to manage a journey with multiple stops."""
@@ -15,6 +18,7 @@ class Journey:
         Initialize a Journey with optional route, trip, and alert information.
         Departure and arrival stops are also initialized as None.
         """
+        self.duration = None
         self.route: Optional[MBTARoute] = None
         self.trip: Optional[MBTATrip] = None
         self.alerts: list[MBTAAlert] = []
@@ -24,9 +28,9 @@ class Journey:
         }
 
     def __repr__(self) -> str:
-        return f"Journey(departure={self.stops['departure']}, arrival={self.stops['arrival']})"
+        return f"Journey(depart_from={self.stops['departure']}, arrive_at={self.stops['arrival']})"
     
-    def add_stop(self, stop_type: str, scheduling_data, stop: MBTAStop, status) -> None:
+    def add_stop(self, stop_type: str, scheduling_data: Union[MBTASchedule,MBTAPrediction], stop: MBTAStop, status) -> None:
         """Add or update a stop to the journey."""
         
         if self.stops[stop_type] is None: 
@@ -52,7 +56,9 @@ class Journey:
                 status
             )
             
-
+        if self.stops['departure'] and self.stops['arrival']:
+            self.duration = MBTAUtils.calculate_time_difference(self.stops['arrival'].get_time(),self.stops['departure'].get_time())
+        
     def get_stop(self, stop_type: str) -> Optional[JourneyStop]:
         """Return the specified stop or None if not set."""
         if stop_type in self.stops:
@@ -107,6 +113,11 @@ class Journey:
             trip_direction = self.trip.direction_id
             return self.route.direction_names[trip_direction]
         return None
+    
+    def get_trip_duration(self) -> Optional[str]:
+        if self.duration:
+            return self.duration
+        return None
 
     def get_stop_name(self, stop_type: str) -> Optional[str]:
         """Return the stop name for the specified stop type."""
@@ -128,6 +139,11 @@ class Journey:
         stop = self.get_stop(stop_type)
         return stop.get_delay() if stop else None
 
+    def get_stop_status(self, stop_type: str) -> Optional[float]:
+        """Return the stop delay for the specified stop type."""
+        stop = self.get_stop(stop_type)
+        return stop.status if stop else None
+    
     def get_stop_time_to(self, stop_type: str) -> Optional[float]:
         """Return the time to for the specified stop type."""
         stop = self.get_stop(stop_type)

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/journey_stop.py

@@ -15,32 +15,41 @@ class JourneyStop:
         
         self.arrival_time = MBTAUtils.parse_datetime(arrival_time)
         self.real_arrival_time = None
-        self.arrival_delay = 0
+        self.arrival_delay = None
 
         self.departure_time = MBTAUtils.parse_datetime(departure_time)
         self.real_departure_time = None
-        self.departure_delay = 0
+        self.departure_delay = None
         
         self.status = status
         self.stop_sequence = stop_sequence
 
     def __repr__(self) -> str:
-        return (f"JourneyStop(stop={self.stop.id})")
+        return (f"JourneyStop(stop={self.stop.name})")
     
-    def update_stop(self, stop: MBTAStop, arrival_time: str, departure_time: str, stop_sequence:str, status: str) -> None:
+    def update_stop(self, stop: MBTAStop, arrival_time: str, departure_time: str, stop_sequence: str, status: str) -> None:
         """Update the stop details, including real arrival and departure times, uncertainties, and delays."""
-                
-        self.stop: MBTAStop = stop
+        
+        self.stop = stop
         self.stop_sequence = stop_sequence
         self.status = status
-        if arrival_time is not None:
-            self.real_arrival_time = MBTAUtils.parse_datetime(arrival_time)
-            if self.arrival_time is not None:
-                self.arrival_delay = MBTAUtils.calculate_time_difference(self.real_arrival_time, self.arrival_time)
-        if departure_time is not None:
-            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)
+        
+        if arrival_time is None and departure_time is None:
+            self.arrival_time = None
+            self.real_arrival_time = None
+            self.arrival_delay = None
+            self.departure_time = None
+            self.real_departure_time = None
+            self.departure_delay = None
+        else:
+            if arrival_time is not None:
+                self.real_arrival_time = MBTAUtils.parse_datetime(arrival_time)
+                if self.arrival_time is not None:
+                    self.arrival_delay = MBTAUtils.calculate_time_difference(self.real_arrival_time, self.arrival_time)
+            if departure_time is not None:
+                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."""

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/journeys_handler.py

@@ -1,4 +1,5 @@
 import aiohttp
+import logging
 
 from datetime import datetime
 
@@ -12,17 +13,20 @@ from mbta_schedule import MBTASchedule
 class JourneysHandler(BaseHandler):
     """Handler for managing a specific journey."""
 
-    def __init__(self, session: aiohttp.ClientSession, api_key: str, depart_from_name: str, arrive_at_name: str, max_journeys: int):
-        super().__init__(session, api_key,depart_from_name,arrive_at_name)
+    def __init__(self, session: aiohttp.ClientSession, logger: logging.Logger,  depart_from_name: str, arrive_at_name: str, max_journeys: int, api_key:str = None) :
+        super().__init__(session, logger, depart_from_name,arrive_at_name, api_key)
         self.max_journeys = max_journeys
     
-    async def fetch_journeys(self) -> list[Journey]:
+    async def async_init(self):
+        await super()._async_init()
+        
+    async def update(self) -> list[Journey]:
        
         schedules = await self.__fetch_schedules()
-        await self._process_schedules(schedules)
+        await super()._process_schedules(schedules)
         
         predictions = await self._fetch_predictions()
-        await self._process_predictions(predictions)
+        await super()._process_predictions(predictions)
         
         self.__sort_and_clean()
         
@@ -31,7 +35,7 @@ class JourneysHandler(BaseHandler):
         await self.__fetch_routes()
         
         alerts = await self._fetch_alerts()
-        self._process_alerts(alerts)  
+        super()._process_alerts(alerts)  
         
         return  list(self.journeys.values())
     
@@ -40,7 +44,7 @@ class JourneysHandler(BaseHandler):
         now = datetime.now().astimezone()
         
         params = {
-            'filter[stop]': ','.join(await self._get_stops_ids()),
+            'filter[stop]': ','.join(super()._get_stops_ids()),
             'filter[min_time]': now.strftime('%H:%M'),
         }
         
@@ -74,12 +78,12 @@ class JourneysHandler(BaseHandler):
     async def __fetch_trips(self):
         """Retrieve trip details for each journey."""
         for trip_id, journey in self.journeys.items():
-            trip: MBTATrip = await self._fetch_trip(trip_id)
+            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 self._fetch_route(journey.trip.route_id)
+                route: MBTARoute = await super()._fetch_route(journey.trip.route_id)
                 journey.route = route              

mbtaclient-0.2.1/src/main.py

@@ -0,0 +1,171 @@
+import aiohttp
+import logging
+from trip_handler import TripHandler
+from journeys_handler import JourneysHandler
+from journey import Journey
+
+_LOGGER = logging.getLogger("MBTAClient")
+
+logging.basicConfig(level=logging.INFO,  # Set the logging level to DEBUG
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+API_KEY = ''
+MAX_JOURNEYS = 1
+
+# DEPART_FROM = 'South Station'
+# ARRIVE_AT = 'Wellesley Square'
+
+# DEPART_FROM = 'Wellesley Square'
+# ARRIVE_AT = 'South Station'
+
+# DEPART_FROM = 'South Station'
+# ARRIVE_AT = 'Braintree'
+
+# DEPART_FROM = 'Copley'
+# ARRIVE_AT = 'Park Street'
+
+# DEPART_FROM = 'North Station'
+# ARRIVE_AT = 'Swampscott'
+
+# DEPART_FROM = 'Dorchester Ave @ Valley Rd'
+# ARRIVE_AT = 'River St @ Standard St'
+
+# DEPART_FROM = 'Back Bay'
+# ARRIVE_AT = 'Huntington Ave @ Opera Pl'
+
+# DEPART_FROM = 'Charlestown Navy Yard'
+# ARRIVE_AT = 'Long Wharf (South)'
+
+# DEPART_FROM = 'North Billerica'
+# ARRIVE_AT = 'North Station'
+
+# DEPART_FROM = 'Back Bay'
+# ARRIVE_AT = 'South Station'
+
+# DEPART_FROM = 'Pemberton Point'
+# ARRIVE_AT = 'Summer St from Cushing Way to Water St (FLAG)'
+
+TRIP = '518'
+DEPART_FROM = 'Wellesley Square'
+ARRIVE_AT = 'South Station'
+
+
+def print_journey(journey: Journey):
+    route_type = journey.get_route_type()
+
+    # if subway or ferry
+    if route_type in [0, 1, 4]:
+        
+        _LOGGER.info("###########")
+        _LOGGER.info("Line: %s", journey.get_route_long_name())  
+        _LOGGER.info("Type: %s", journey.get_route_description())        
+        _LOGGER.info("Color: %s", journey.get_route_color())
+        _LOGGER.info("**********")       
+        _LOGGER.info("Direction: %s to %s", journey.get_trip_direction(), journey.get_trip_destination())
+        _LOGGER.info("Destination: %s", journey.get_trip_headsign())
+        _LOGGER.info("Duration: %s", journey.get_trip_duration())
+        _LOGGER.info("**********")   
+        _LOGGER.info("Departure Station: %s", journey.get_stop_name('departure'))
+        _LOGGER.info("Departure Platform: %s", journey.get_platform_name('departure'))
+        _LOGGER.info("Departure Time: %s", journey.get_stop_time('departure'))
+        _LOGGER.info("Departure Delay: %s", journey.get_stop_delay('departure'))
+        _LOGGER.info("Departure Time To: %s", journey.get_stop_time_to('departure'))
+        _LOGGER.info("%s", journey.get_stop_status('departure'))
+        _LOGGER.info("**********")   
+        _LOGGER.info("Arrival Station: %s", journey.get_stop_name('arrival'))
+        _LOGGER.info("Arrival Platform: %s", journey.get_platform_name('arrival'))
+        _LOGGER.info("Arrival Time: %s", journey.get_stop_time('arrival'))
+        _LOGGER.info("Arrival Delay: %s", journey.get_stop_delay('arrival'))
+        _LOGGER.info("Arrival Time To: %s", journey.get_stop_time_to('arrival'))
+        _LOGGER.info("%s", journey.get_stop_status('arrival'))
+        _LOGGER.info("**********")   
+        for j in range(len(journey.alerts)):
+            _LOGGER.info("Alert: %s", journey.get_alert_header(j))
+        
+    # if train
+    elif route_type == 2:    
+        
+        _LOGGER.info("###########")
+        _LOGGER.info("Line: %s", journey.get_route_long_name())  
+        _LOGGER.info("Type: %s", journey.get_route_description())        
+        _LOGGER.info("Color: %s", journey.get_route_color())
+        _LOGGER.info("Train Number: %s", journey.get_trip_name())
+        _LOGGER.info("**********")   
+        _LOGGER.info("Direction: %s to %s", journey.get_trip_direction(), journey.get_trip_destination())
+        _LOGGER.info("Destination: %s", journey.get_trip_headsign())
+        _LOGGER.info("Duration: %s", journey.get_trip_duration())
+        _LOGGER.info("**********")   
+        _LOGGER.info("Departure Station: %s", journey.get_stop_name('departure'))
+        _LOGGER.info("Departure Platform: %s", journey.get_platform_name('departure'))
+        _LOGGER.info("Departure Time: %s", journey.get_stop_time('departure'))
+        _LOGGER.info("Departure Delay: %s", journey.get_stop_delay('departure'))
+        _LOGGER.info("Departure Time To: %s", journey.get_stop_time_to('departure'))
+        _LOGGER.info("%s", journey.get_stop_status('departure'))
+        _LOGGER.info("**********")   
+        _LOGGER.info("Arrival Station: %s", journey.get_stop_name('arrival'))
+        _LOGGER.info("Arrival Platform: %s", journey.get_platform_name('arrival'))
+        _LOGGER.info("Arrival Time: %s", journey.get_stop_time('arrival'))
+        _LOGGER.info("Arrival Delay: %s", journey.get_stop_delay('arrival'))
+        _LOGGER.info("Arrival Time To: %s", journey.get_stop_time_to('arrival'))
+        _LOGGER.info("%s", journey.get_stop_status('arrival'))
+        _LOGGER.info("**********")   
+        for j in range(len(journey.alerts)):
+            _LOGGER.info("Alert: %s", journey.get_alert_header(j))
+        
+    # if bus
+    elif route_type == 3:
+
+        _LOGGER.info("###########")
+        _LOGGER.info("Line: %s", journey.get_route_short_name())  
+        _LOGGER.info("Type: %s", journey.get_route_description())        
+        _LOGGER.info("Color: %s", journey.get_route_color())
+        _LOGGER.info("**********")   
+        _LOGGER.info("Direction: %s to %s", journey.get_trip_direction(), journey.get_trip_destination())
+        _LOGGER.info("Destination: %s", journey.get_trip_headsign())
+        _LOGGER.info("Duration: %s", journey.get_trip_duration())
+        _LOGGER.info("**********")   
+        _LOGGER.info("Departure Stop: %s", journey.get_stop_name('departure'))
+        _LOGGER.info("Departure Time: %s", journey.get_stop_time('departure'))
+        _LOGGER.info("Departure Delay: %s", journey.get_stop_delay('departure'))
+        _LOGGER.info("Departure Time To: %s", journey.get_stop_time_to('departure'))
+        _LOGGER.info("%s", journey.get_stop_status('departure'))
+        _LOGGER.info("**********")   
+        _LOGGER.info("Arrival Stop: %s", journey.get_stop_name('arrival'))
+        _LOGGER.info("Arrival Time: %s", journey.get_stop_time('arrival'))
+        _LOGGER.info("Arrival Delay: %s", journey.get_stop_delay('arrival'))
+        _LOGGER.info("Arrival Time To: %s", journey.get_stop_time_to('arrival'))
+        _LOGGER.info("%s", journey.get_stop_status('arrival'))
+        _LOGGER.info("**********")   
+        for j in range(len(journey.alerts)):
+            _LOGGER.info("Alert: %s", journey.get_alert_header(j))
+
+    else:
+        _LOGGER.error('ARGH!')
+                
+                
+async def main():
+    async with aiohttp.ClientSession() as session:
+        
+        trip_hadler = TripHandler(session, _LOGGER, DEPART_FROM, ARRIVE_AT, TRIP, API_KEY)
+        
+        await trip_hadler.async_init()
+        
+        trips = await trip_hadler.update()
+        
+        for trip in trips:
+            print_journey(trip)
+        
+        journeys_handler = JourneysHandler(session, _LOGGER, DEPART_FROM, ARRIVE_AT, MAX_JOURNEYS, API_KEY)
+        
+        await journeys_handler.async_init()
+         
+        journeys  = await journeys_handler.update()
+        
+        for journey in journeys:
+            print_journey(journey)
+
+            
+                                
+# Run the main function
+import asyncio
+asyncio.run(main())

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/mbta_alert.py

@@ -32,7 +32,7 @@ class MBTAAlert:
         ]
 
     def __repr__(self) -> str:
-        return (f"MBTAalert(id={self.alert_id}, header_text={self.header_text})")
+        return (f"MBTAalert(id={self.alert_id})")
 
     def get_informed_stops(self) -> list[str]:
         """Retrieve a list of unique stops from informed entities."""

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/mbta_client.py

@@ -23,10 +23,10 @@ ENDPOINTS = {
 class MBTAClient:
     """Class to interact with the MBTA v3 API."""
 
-    def __init__(self, session: aiohttp.ClientSession, api_key: Optional[str] = None) -> None:
+    def __init__(self, session: aiohttp.ClientSession,  logger: logging.Logger, api_key: Optional[str] = None)-> None:
         self._session = session
         self._api_key = api_key
-
+        self.logger: logging.Logger = logger
     
     async def get_route(self, id: str, params: Optional[dict[str, Any]] = None) -> MBTARoute:
         """Get a route by its ID."""
@@ -82,7 +82,7 @@ class MBTAClient:
                 raise ValueError("Unexpected response format")
             return data
         except Exception as error:
-            logging.error(f"Error fetching data: {error}")
+            self.logger.error(f"Error fetching data: {error}")
             raise
         
     async def request(
@@ -106,13 +106,13 @@ class MBTAClient:
             return response
             
         except ClientConnectionError as error:
-            logging.error(f"Connection error: {error}")
+            self.logger.error(f"Connection error: {error}")
             raise
         except ClientResponseError as error:
-            logging.error(f"Client response error: {error.status} - {str(error)}")
+            self.logger.error(f"Client response error: {error.status} - {str(error)}")
             raise
         except Exception as error:
-            logging.error(f"An unexpected error occurred: {error}")
+            self.logger.error(f"An unexpected error occurred: {error}")
             raise        
 
 

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/mbta_prediction.py

@@ -27,6 +27,6 @@ class MBTAPrediction:
         self.trip_id: str = prediction.get('relationships', {}).get('trip', {}).get('data', {}).get('id', '')
 
     def __repr__(self) -> str:
-        return (f"MBTAprediction(id={self.id}, route_id={self.route_id}, stop_id={self.stop_id}, trip_id={self.trip_id})")
+        return (f"MBTAprediction(id={self.id})")
 
    

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/mbta_schedule.py

@@ -22,5 +22,5 @@ class MBTASchedule:
         self.trip_id: str = relationships.get('trip', {}).get('data', {}).get('id', '')
 
     def __repr__(self) -> str:
-        return (f"MBTAschedule(id={self.id}, route_id={self.route_id}, stop_id={self.stop_id}, trip_id={self.trip_id})")
+        return (f"MBTAschedule(id={self.id})")
 

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/mbta_stop.py

@@ -22,5 +22,5 @@ class MBTAStop:
         self.wheelchair_boarding: int = attributes.get('wheelchair_boarding', 0)
 
     def __repr__(self) -> str:
-        return (f"MBTAstop(id={self.id}, name={self.name})")
+        return (f"MBTAstop(id={self.id})")
 

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/mbta_trip.py

@@ -23,7 +23,7 @@ class MBTATrip:
 
     
     def __repr__(self) -> str:
-        return (f"MBTAtrip(id={self.id}, route_id={self.route_id})")
+        return (f"MBTAtrip(id={self.id})")
  
 
 

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/mbta_utils.py

@@ -1,5 +1,4 @@
 from datetime import datetime
-import logging
 from typing import Optional
 
 class MBTAUtils:
@@ -46,10 +45,6 @@ class MBTAUtils:
     @staticmethod
     def parse_datetime(time_str: str) -> Optional[datetime]:
         """Parse a string in ISO 8601 format to a datetime object."""
-        if time_str is None:
+        if not isinstance(time_str, str):
             return None
-        try:
-            return datetime.fromisoformat(time_str)
-        except ValueError as e:
-            logging.error(f"Error parsing datetime: {e}")
-            return None
+        return datetime.fromisoformat(time_str)

{mbtaclient-0.2.0 → mbtaclient-0.2.1}/src/trip_handler.py

@@ -1,3 +1,5 @@
+from typing import Optional
+import traceback
 import aiohttp
 
 from base_handler import BaseHandler
@@ -10,46 +12,41 @@ from mbta_prediction import MBTAPrediction
 class TripHandler(BaseHandler):
     """Handler for managing a specific trip."""
 
-    def __init__(self, session: aiohttp.ClientSession, api_key: str, depart_from_name: str, arrive_at_name: str, trip_name: str):
-        super().__init__(session, api_key,depart_from_name,arrive_at_name)
+    def __init__(self, session: aiohttp.ClientSession, logger,  depart_from_name: str, arrive_at_name: str, trip_name: str, api_key:str = None ) :
+        super().__init__(session, logger, depart_from_name, arrive_at_name, api_key) 
         self.trip_name = trip_name
         
-    async def fetch_trip(self):
-        
-        await self.trip_init()
-       
-        schedules = await self.__fetch_schedules()
-        await self._process_schedules(schedules)
-        
-        predictions = await self.__fetch_predictions()
-        await self._process_predictions(predictions)
-        
-        alerts = await self.__fetch_alerts()
-        self._process_alerts(alerts)  
-        
-        return  next(iter(self.journeys.values()))
-    
-    
-    async def trip_init(self):
-        
+            
+    async def async_init(self):
+        await super()._async_init()
+
         params = {
             'filter[revenue]' :'REVENUE',
             'filter[name]' : self.trip_name
         }
-        
-        trips: list[MBTATrip] = await self.mbta_client.list_trips(params)
+        trips: list[MBTATrip] = await super()._fetch_trips(params)
         
         journey = Journey()
-        
         journey.trip = trips[0]
         
-        route: MBTARoute = await self.mbta_client.get_route(journey.trip.route_id)
+        route: MBTARoute = await super()._fetch_route(journey.trip.route_id)
         
         journey.route = route
-        
         self.journeys[trips[0].id] = journey
-
-
+    
+    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)
+        
+        alerts = await self.__fetch_alerts()
+        super()._process_alerts(alerts)  
+        return  list(self.journeys.values())
+    
+    
     async def __fetch_schedules(self) -> list[MBTASchedule]:
         
         jounrey = next(iter(self.journeys.values()))
@@ -60,7 +57,6 @@ class TripHandler(BaseHandler):
         }
         
         schedules = await super()._fetch_schedules(params)
-        
         return schedules
 
 
@@ -74,7 +70,6 @@ class TripHandler(BaseHandler):
         }
         
         predictions = await super()._fetch_predictions(params)
-        
         return predictions                   
 
 
@@ -88,5 +83,4 @@ class TripHandler(BaseHandler):
         }
         
         alerts = await super()._fetch_alerts(params)
-        
         return alerts   

mbtaclient-0.2.0/src/main.py

@@ -1,173 +0,0 @@
-import aiohttp
-from trip_handler import TripHandler
-from journeys_handler import JourneysHandler
-
-
-API_KEY = ''
-MAX_JOURNEYS = 5
-
-
-# DEPART_FROM = 'South Station'
-# ARRIVE_AT = 'Wellesley Square'
-
-
-# DEPART_FROM = 'Wellesley Square'
-# ARRIVE_AT = 'South Station'
-
-
-# DEPART_FROM = 'South Station'
-# ARRIVE_AT = 'Braintree'
-
-
-# DEPART_FROM = 'Copley'
-# ARRIVE_AT = 'Park Street'
-
-
-# DEPART_FROM = 'North Station'
-# ARRIVE_AT = 'Swampscott'
-
-
-# DEPART_FROM = 'Dorchester Ave @ Valley Rd'
-# ARRIVE_AT = 'River St @ Standard St'
-
-
-# DEPART_FROM = 'Back Bay'
-# ARRIVE_AT = 'Huntington Ave @ Opera Pl'
-
-# DEPART_FROM = 'Charlestown Navy Yard'
-# ARRIVE_AT = 'Long Wharf (South)'
-
-
-
-# DEPART_FROM = 'North Billerica'
-# ARRIVE_AT = 'North Station'
-
-# DEPART_FROM = 'Back Bay'
-# ARRIVE_AT = 'South Station'
-
-# DEPART_FROM = 'Pemberton Point'
-# ARRIVE_AT = 'Summer St from Cushing Way to Water St (FLAG)'
-
-TRIP = '518'
-DEPART_FROM = 'Wellesley Square'
-ARRIVE_AT = 'South Station'
-
-
-def print_journey(journey):
-    route_type = journey.get_route_type()
-
-    # if subway or ferry
-    if route_type == 0 or route_type == 1 or route_type == 4:
-        
-        print("###########")
-        print() 
-        print("Line:", journey.get_route_long_name())  
-        print("Type:", journey.get_route_description())        
-        print("Color:", journey.get_route_color())
-        print() 
-        print("Direction:", journey.get_trip_direction()+" to "+journey.get_trip_destination())
-        print("Destination:", journey.get_trip_headsign())
-        print() 
-        # Print departure information
-        print("Departure Station:", journey.get_stop_name('departure'))
-        print("Departure Platform:", journey.get_platform_name('departure'))
-        print("Departure Time:", journey.get_stop_time('departure'))
-        print("Departure Delay:", journey.get_stop_delay('departure'))
-        print("Departure Time To:", journey.get_stop_time_to('departure'))
-        print() 
-        # Print arrival information
-        print("Arrival Station:", journey.get_stop_name('arrival'))
-        print("Arrival Platform:", journey.get_platform_name('arrival'))
-        print("Arrival Time:", journey.get_stop_time('arrival'))
-        print("Arrival Delay:", journey.get_stop_delay('arrival'))
-        print("Arrival Time To:", journey.get_stop_time_to('arrival'))
-        print() 
-        for j in range(len(journey.alerts)):
-            print("Alert:" , journey.get_alert_header(j))
-            print() 
-    
-    # if train
-    elif route_type == 2:    
-                                            
-        print("###########")
-        print() 
-        print("Line:", journey.get_route_long_name())  
-        print("Type:", journey.get_route_description())        
-        print("Color:", journey.get_route_color())
-        print() 
-        print("Train Number:", journey.get_trip_name())
-        print("Direction:", journey.get_trip_direction()+" to "+journey.get_trip_destination())
-        print("Destination:", journey.get_trip_headsign())
-        print() 
-        # Print departure information
-        print("Departure Station:", journey.get_stop_name('departure'))
-        print("Departure Platform:", journey.get_platform_name('departure'))
-        print("Departure Time:", journey.get_stop_time('departure'))
-        print("Departure Delay:", journey.get_stop_delay('departure'))
-        print("Departure Time To:", journey.get_stop_time_to('departure'))
-        print() 
-        # Print arrival information
-        print("Arrival Station:", journey.get_stop_name('arrival'))
-        print("Arrival Platform:", journey.get_platform_name('arrival'))
-        print("Arrival Time:", journey.get_stop_time('arrival'))
-        print("Arrival Delay:", journey.get_stop_delay('arrival'))
-        print("Arrival Time To:", journey.get_stop_time_to('arrival'))
-        print() 
-            
-        for j in range(len(journey.alerts)):
-            print("Alert:" , journey.get_alert_header(j))
-            print() 
-    
-    #if bus
-    elif route_type == 3:
-
-        print("###########")
-        print() 
-        print("Line:", journey.get_route_short_name())  
-        print("Type:", journey.get_route_description())        
-        print("Color:", journey.get_route_color())
-        print() 
-        print("Direction:", journey.get_trip_direction()+" to "+journey.get_trip_destination())
-        print("Destination:", journey.get_trip_headsign())
-       # Print departure information
-        print("Departure Stop:", journey.get_stop_name('departure'))
-        print("Departure Time:", journey.get_stop_time('departure'))
-        print("Departure Delay:", journey.get_stop_delay('departure'))
-        print("Departure Time To:", journey.get_stop_time_to('departure'))
-        print() 
-        # Print arrival information
-        print("Arrival Stop:", journey.get_stop_name('arrival'))
-        print("Arrival Time:", journey.get_stop_time('arrival'))
-        print("Arrival Delay:", journey.get_stop_delay('arrival'))
-        print("Arrival Time To:", journey.get_stop_time_to('arrival'))
-        print()  
-        for j in range(len(journey.alerts)):
-            print("Alert:" , journey.get_alert_header(j))
-            print() 
-                        
-    else:
-        
-            print('ARGH!') 
-                
-                
-async def main():
-    async with aiohttp.ClientSession() as session:
-        
-        trip_hadler = TripHandler(session, API_KEY, DEPART_FROM, ARRIVE_AT, TRIP)
-        
-        trip = await trip_hadler.fetch_trip()
-        
-        print_journey(trip)
-        
-        journeys_handler = JourneysHandler(session, API_KEY, DEPART_FROM, ARRIVE_AT, MAX_JOURNEYS)
-        
-        journeys  = await journeys_handler.fetch_journeys()
-        
-        for journey in journeys:
-            print_journey(journey)
-
-            
-                                
-# Run the main function
-import asyncio
-asyncio.run(main())