MBTAclient 0.2.4__tar.gz → 0.2.6__tar.gz

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

@@ -1,10 +1,15 @@
 Metadata-Version: 2.1
 Name: MBTAclient
-Version: 0.2.4
+Version: 0.2.6
 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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MBTAclient"
-version = "0.2.4"
+version = "0.2.6"
 description = "A Python client for interacting with the MBTA API"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -12,6 +12,14 @@ dependencies = [
     "aiohttp>=3.9.5"
 ]
 
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+
 [[project.authors]]
 name = "Luca Chiabrera"
 email = "luca.chiabrera@gmail.com"
@@ -20,6 +28,5 @@ email = "luca.chiabrera@gmail.com"
 Homepage = "https://github.com/chiabre/MBTAclient"
 Issues = "https://github.com/chiabre/MBTAclient/issues"
 
-
 [tool.setuptools.packages.find]
 where = ["src"]

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

@@ -1,10 +1,15 @@
 Metadata-Version: 2.1
 Name: MBTAclient
-Version: 0.2.4
+Version: 0.2.6
 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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE

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

@@ -7,6 +7,7 @@ src/MBTAclient.egg-info/dependency_links.txt
 src/MBTAclient.egg-info/requires.txt
 src/MBTAclient.egg-info/top_level.txt
 src/mbtaclient/__init__.py
+src/mbtaclient/__version__.py
 src/mbtaclient/base_handler.py
 src/mbtaclient/journey.py
 src/mbtaclient/journey_stop.py

mbtaclient-0.2.6/src/mbtaclient/__init__.py

@@ -0,0 +1,31 @@
+# mbtaclient/__init__.py
+
+
+from .journey_stop import JourneyStop
+from .journey import Journey
+from .journeys_handler import JourneysHandler
+from .mbta_alert import MBTAAlert
+from .mbta_client import MBTAClient
+from .mbta_prediction import MBTAPrediction
+from .mbta_route import MBTARoute
+from .mbta_schedule import MBTASchedule
+from .mbta_stop import MBTAStop
+from .mbta_trip import MBTATrip
+from .trip_handler import TripHandler
+from .__version__ import __version__
+
+__all__ = [
+    "JourneyStop",
+    "Journey",
+    "JourneysHandler",
+    "MBTAAlert",
+    "MBTAClient",
+    "MBTARoute",
+    "MBTATrip",
+    "MBTAStop",
+    "MBTASchedule",
+    "MBTAPrediction",
+    "TripHandler",
+]
+
+__version__ = __version__

mbtaclient-0.2.6/src/mbtaclient/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.2.5"

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

@@ -1,25 +1,23 @@
 import logging
-import traceback
 import aiohttp
 
 from typing import Optional
-from datetime import date
 
-
-from mbta_client import MBTAClient
-from journey import Journey
-from mbta_stop import MBTAStop
-from mbta_route import MBTARoute
-from mbta_schedule import MBTASchedule
-from mbta_prediction import MBTAPrediction
-from mbta_trip import MBTATrip
-from mbta_alert import MBTAAlert
+from .mbta_client import MBTAClient
+from .journey import Journey
+from .mbta_stop import MBTAStop
+from .mbta_route import MBTARoute
+from .mbta_schedule import MBTASchedule
+from .mbta_prediction import MBTAPrediction
+from .mbta_trip import MBTATrip
+from .mbta_alert import MBTAAlert
+from .mbta_utils import memoize_async
 
 
 class BaseHandler:
     """Base class for handling MBTA journeys."""
     
-    def __init__(self, session: aiohttp.ClientSession, logger: logging.Logger, depart_from_name: str , arrive_at_name: str, api_key: str = None) -> None:
+    def __init__(self, depart_from_name: str , arrive_at_name: str, api_key: str = None, session: aiohttp.ClientSession = None, logger: logging.Logger = None) -> None:
     
         self.depart_from = {
             'name' : depart_from_name,
@@ -31,20 +29,14 @@ class BaseHandler:
             'stops' : None,
             'ids' : None
         }
-        self.mbta_client = MBTAClient(session,logger, api_key=api_key)
+        
+        client_session = session or aiohttp.ClientSession()
+        self.mbta_client = MBTAClient(client_session,logger,api_key)
 
         self.journeys: dict[str, Journey] = {} 
-  
-        # Caches 
-        self._stops_cache: Optional[list[MBTAStop]] = None
-        self._schedules_cache: Optional[list[MBTASchedule]] = None  
-        self._schedules_cache_date: Optional[date] = None
-        self._trip_cache: dict[str, MBTATrip] = {}
-        self._route_cache: dict[str, MBTARoute] = {}
+
+        self.logger: logging.Logger = logger or logging.getLogger(__name__)
         
-        # 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']})")
  
@@ -53,56 +45,52 @@ class BaseHandler:
         stops = await self.__fetch_stops()
         self.__process_stops(stops)
     
+    @memoize_async()
     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:
-            return self._stops_cache
-
-        # Cache is empty, so we fetch the stops from the API
+        """Retrive stops """
+        self.logger.debug("Retriving 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)
-            self.logger.debug("Updating cached stops")
-            self._stops_cache = stops
             return stops
-        
         except Exception as e:
-            self.logger.error(f"Error fetching stops: {e}")
-            traceback.print_exc()
+            self.logger.error(f"Error retriving MBTA stops: {e}")
             return []
         
-    def  __process_stops(self, stops: list[MBTAStop]):
+    def __process_stops(self, stops: list[MBTAStop]):
+        self.logger.debug("Processing MBTA stops")
         depart_from_stops = []
         depart_from_ids = []
         arrive_at_stops = []
         arrive_at_ids = []
+
         for stop in stops:
+            if not isinstance(stop, MBTAStop):  # Validate data type
+                self.logger.warning(f"Unexpected data type for stop: {type(stop)}")
+                continue  # Skip invalid data
+
             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']}")
-        
+            self.logger.error(f"Error processing MBTA stop data for {self.depart_from['name']}")
+            raise MBTAStopError(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
+            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.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']):
@@ -120,106 +108,116 @@ class BaseHandler:
             return self.arrive_at['ids']  
         return None           
     
+    @memoize_async(expire_at_end_of_day=True)
     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():
-            self.logger.debug("Returning cached schedules")
-            return self._schedules_cache
-
+        """Retrive MBTA schedules"""
+        self.logger.debug("Retriving MBTA schedules")
         base_params = {
             'filter[stop]': ','.join(self._get_stops_ids()),
             'sort': 'departure_time'
         }
         if params is not None:
             base_params.update(params)
-
         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()
+            schedules: list[MBTASchedule] = await self.mbta_client.list_schedules(params)
             return schedules
         except Exception as e:
-            self.logger.error(f"Error fetching schedules: {e}")
-            traceback.print_exc()
+            self.logger.error(f"Error retriving MBTA schedules: {e}")
             return []
             
     async def _process_schedules(self, schedules: list[MBTASchedule]):
-        self.logger.debug("Processing schedules")
-              
-        for schedule in schedules:               
-            
-            # if the schedule trip id not in the journeys
+        self.logger.debug("Processing MBTA schedules")
+
+        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}")
+                continue  # Skip to the next schedule
+
+            # If the schedule trip_id is not in the journeys
             if schedule.trip_id not in self.journeys:
-                # create the journey
+                # Create the journey
                 journey = Journey()
-                # add the journey to the journeys dict using the trip_id as key
+                # Add the journey to the journeys dict using the trip_id as key
                 self.journeys[schedule.trip_id] = journey
-                
-            stop: MBTAStop = self.__get_stop_by_id(schedule.stop_id)
+
+            # 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")
+                continue  # Skip to the next schedule
+
             departure_stops_ids = self.__get_stops_ids_by_stop_type('departure')
             arrival_stops_ids = self.__get_stops_ids_by_stop_type('arrival')
-            
+
+            # Check if the stop_id is in the departure or arrival stops lists
             if schedule.stop_id in departure_stops_ids:
-                self.journeys[schedule.trip_id].add_stop('departure',schedule,stop,'SCHEDULED')
+                self.journeys[schedule.trip_id].add_stop('departure', schedule, stop, 'SCHEDULED')
             elif schedule.stop_id in arrival_stops_ids:
-                self.journeys[schedule.trip_id].add_stop('arrival',schedule, stop,'SCHEDULED')
+                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}")
+        
     
 
     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")
-                
+        """Retrive MBTA predictions based on the provided stop IDs"""
+        self.logger.debug("Retriving MBTA predictions")
         base_params = {
             'filter[stop]': ','.join(self._get_stops_ids()),
             'filter[revenue]': 'REVENUE',
             'sort': 'departure_time'
         }
-        
         if params is not None:
             base_params.update(params)           
-        
         try:
             predictions: list[MBTAPrediction] = await self.mbta_client.list_predictions(base_params)
             return predictions
-        
         except Exception as e:
-            self.logger.error(f"Error fetching predictions: {e}")
-            traceback.print_exc()
+            self.logger.error(f"Error retriving MBTA predictions: {e}")
+
           
-    async def _process_predictions (self, predictions: list[MBTAPrediction]):   
-        self.logger.debug("Processing predictions")
-                
+    async def _process_predictions(self, predictions: list[MBTAPrediction]):
+        self.logger.debug("Processing MBTA predictions")
+
         for prediction in predictions:
-        
-            # if the trip of the prediciton is not in the journeys dict
-            if prediction.trip_id not in self.journeys:             
-                # create the journey
+            # Validate prediction data
+            if not prediction.trip_id or not prediction.stop_id:
+                self.logger.error(f"Invalid prediction data: {prediction}")
+                continue  # Skip to the next prediction
+
+            # If the trip of the prediction is not in the journeys dict
+            if prediction.trip_id not in self.journeys:
+                # Create the journey
                 journey = Journey()
-                # add the journey to the journeys dict using the trip_id as key
+                # Add the journey to the journeys dict using the trip_id as key
                 self.journeys[prediction.trip_id] = journey
-                
-            stop: MBTAStop = self.__get_stop_by_id(prediction.stop_id)
+
+            # 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}")
+                continue  # Skip to the next prediction
+
             departure_stops_ids = self.__get_stops_ids_by_stop_type('departure')
             arrival_stops_ids = self.__get_stops_ids_by_stop_type('arrival')
-                        
+
+            # Default schedule relationship to 'PREDICTED' if not set
             if prediction.schedule_relationship is None:
-                prediction.schedule_relationship = 'PREDICTED'   
-            
-            # if the prediction stop id is in the departure stop ids
+                prediction.schedule_relationship = 'PREDICTED'
+
+            # Check if the prediction stop_id is in the departure or arrival stops lists
             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_stops_ids:
-                self.journeys[prediction.trip_id].add_stop('arrival',prediction,stop,prediction.schedule_relationship)
+                self.journeys[prediction.trip_id].add_stop('departure', prediction, stop, prediction.schedule_relationship)
+            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}")
+                
 
     async def _fetch_alerts(self,params: str = None) -> list[MBTAAlert]:
-        """Retrieve and associate alerts with the relevant journeys."""
-        self.logger.debug("Fetching MBTA alerts")
+        """Retrive MBTA alerts"""
+        self.logger.debug("Retriving MBTA alerts")
                 
         # Prepare filter parameters
         base_params = {
@@ -235,22 +233,31 @@ class BaseHandler:
             alerts: list[MBTAAlert] = await self.mbta_client.list_alerts(base_params)
             return alerts
         except Exception as e:
-            self.logger.error(f"Error fetching alerts: {e}")
-            traceback.print_exc()
+            self.logger.error(f"Error retriving MBTA alerts: {e}")
+
             
     def _process_alerts(self, alerts: list[MBTAAlert]):
-        self.logger.debug("Processing alerts")
+        self.logger.debug("Processing MBTA alerts")
         
         for alert in alerts:
-            
+            # Validate alert data
+            if not alert.id or not alert.effect:
+                self.logger.error(f"Invalid alert data: {alert}")
+                continue  # Skip to the next alert
+
             # Iterate through each journey and associate relevant alerts
             for journey in self.journeys.values():
-                if alert in journey.alerts:
+            # 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
 
                 # Check if the alert is relevant to the journey
-                if self.__is_alert_relevant(alert, journey):
-                    journey.alerts.append(alert)
+                try:
+                    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}")
+                    continue  # Skip to the next journey if an error occurs
 
     def __is_alert_relevant(self, alert: MBTAAlert, journey: Journey) -> bool:
         """Check if an alert is relevant to a given journey."""
@@ -281,55 +288,42 @@ class BaseHandler:
             return False
         return True
     
+    @memoize_async()
     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:
-            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
+        """Retrieve MBTA trip based on trip_id."""
+        self.logger.debug(f"Retriving MBTA trip: {trip_id} ")
         try:
             trip: MBTATrip = await self.mbta_client.get_trip(trip_id, params)
-            self.logger.debug(f"Updating cached trip: {trip_id}")
-            self._trip_cache[trip_id] = trip
             return trip
-        
         except Exception as e:
-            self.logger.error(f"Error fetching trip: {e}")
-            traceback.print_exc()
+            self.logger.error(f"Error fetching trip {trip_id}: {e}")
             return None
-        
+    
+    @memoize_async()
     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:
-            return self._route_cache[route_id]
-        
-        # Trip is not in the cache, so fetch it from the API
+        """Retrive MBTA route based on route_id."""
+        self.logger.debug(f"Retriving MBTA route: {route_id} ")
         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:
-            self.logger.error(f"Error fetching route: {e}")
-            traceback.print_exc()
+            self.logger.error(f"Error retriving MBTA route {route_id}: {e}")
             return None
-        
+    
+    @memoize_async()
     async def _fetch_trips(self, params: dict = None) -> Optional[MBTARoute]:
-        self.logger.debug("Fetching MBTA trips")
+        """Retrive MBTA trips"""
+        self.logger.debug("Retriving 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()
+            self.logger.error(f"Error retriving MBTA route: {e}")
             return None
         
+
+class MBTAStopError(Exception):
+    pass
+
+class MBTATripError(Exception):
+    pass

{mbtaclient-0.2.4 → mbtaclient-0.2.6}/src/mbtaclient/journey.py

@@ -1,14 +1,14 @@
 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
+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."""
@@ -90,7 +90,6 @@ class Journey:
         return self.route.color if self.route else None
 
     def get_route_description(self) -> Optional[str]:
-        from mbta_utils import MBTAUtils
         return MBTAUtils.get_route_type_desc_by_type_id(self.route.type) if self.route else None
 
     def get_route_type(self) -> Optional[str]:

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

@@ -1,8 +1,8 @@
 from typing import Optional
 from datetime import datetime
 
-from mbta_stop import MBTAStop
-from mbta_utils import MBTAUtils
+from .mbta_stop import MBTAStop
+from .mbta_utils import MBTAUtils
 
 
 class JourneyStop:

{mbtaclient-0.2.4 → mbtaclient-0.2.6}/src/mbtaclient/journeys_handler.py

@@ -3,18 +3,18 @@ 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
+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, 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)
+    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):

{mbtaclient-0.2.4 → mbtaclient-0.2.6}/src/mbtaclient/mbta_alert.py

@@ -7,7 +7,7 @@ class MBTAAlert:
         attributes = alert.get('attributes', {})
         
         # Basic attributes
-        self.alert_id: str = alert.get('id', '')
+        self.id: str = alert.get('id', '')
         self.active_period_start: Optional[str] = attributes.get('active_period', [{}])[0].get('start', None)
         self.active_period_end: Optional[str] = attributes.get('active_period', [{}])[0].get('end', None)
         self.cause: str = attributes.get('cause', '')

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

@@ -2,12 +2,13 @@ import aiohttp
 import logging
 from aiohttp import ClientConnectionError, ClientResponseError
 from typing import Optional, Any
-from mbta_route import MBTARoute
-from mbta_stop import MBTAStop
-from mbta_schedule import MBTASchedule
-from mbta_prediction import MBTAPrediction
-from mbta_trip import MBTATrip
-from mbta_alert import MBTAAlert
+
+from .mbta_route import MBTARoute
+from .mbta_stop import MBTAStop
+from .mbta_schedule import MBTASchedule
+from .mbta_prediction import MBTAPrediction
+from .mbta_trip import MBTATrip
+from .mbta_alert import MBTAAlert
 
 MBTA_DEFAULT_HOST = "api-v3.mbta.com"
 
@@ -23,10 +24,10 @@ ENDPOINTS = {
 class MBTAClient:
     """Class to interact with the MBTA v3 API."""
 
-    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
+    def __init__(self, session: aiohttp.ClientSession = None,  logger: logging.Logger = None, api_key: Optional[str] = None)-> None:
+        self._session = session or aiohttp.ClientSession()
+        self.logger: logging.Logger = logger or logging.getLogger(__name__)
+        self._api_key: str = api_key 
     
     async def get_route(self, id: str, params: Optional[dict[str, Any]] = None) -> MBTARoute:
         """Get a route by its ID."""

{mbtaclient-0.2.4 → mbtaclient-0.2.6}/src/mbtaclient/mbta_prediction.py

@@ -1,6 +1,6 @@
 
 from typing import Any, Optional
-from mbta_utils import MBTAUtils
+from .mbta_utils import MBTAUtils
 
 class MBTAPrediction:
     """A prediction object to hold information about a prediction."""

mbtaclient-0.2.6/src/mbtaclient/mbta_utils.py

@@ -0,0 +1,100 @@
+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__)
+
+
+class MBTAUtils:
+        
+    ROUTE_TYPES= {
+        # 0: 'Light Rail',   # Example: Green Line
+        # 1: 'Heavy Rail',   # Example: Red Line
+        0: 'Subway',   
+        1: 'Subway',  
+        2: 'Commuter Rail',
+        3: 'Bus',
+        4: 'Ferry'
+    }
+
+    UNCERTAINTY = {
+        '60': 'Trip that has already started',
+        '120': 'Trip not started and a vehicle is awaiting departure at the origin',
+        '300': 'Vehicle has not yet been assigned to the trip',
+        '301': 'Vehicle appears to be stalled or significantly delayed',
+        '360': 'Trip not started and a vehicle is completing a previous trip'
+    }
+           
+    @staticmethod
+    def get_route_type_desc_by_type_id(route_type: int) -> str:
+        """Get a description of the route type."""
+        return MBTAUtils.ROUTE_TYPES.get(route_type, 'Unknown')
+    
+    @staticmethod
+    def get_uncertainty_description(key: str) -> str:
+        return MBTAUtils.UNCERTAINTY.get(key, 'None')
+    
+    @staticmethod
+    def time_to(time: Optional[datetime], now: datetime) -> Optional[float]:
+        if time is None:
+            return None
+        return (time - now).total_seconds()
+
+    @staticmethod
+    def calculate_time_difference(real_time: Optional[datetime], time: Optional[datetime]) -> Optional[float]:
+        if real_time is None or time is None:
+            return None
+        return (real_time - time).total_seconds()
+
+    @staticmethod
+    def parse_datetime(time_str: str) -> Optional[datetime]:
+        """Parse a string in ISO 8601 format to a datetime object."""
+        if not isinstance(time_str, str):
+            return None
+        return datetime.fromisoformat(time_str)
+    
+
+
+from datetime import datetime, timedelta
+import logging
+
+logger = logging.getLogger(__name__)
+
+def memoize_async(expire_at_end_of_day=False):
+    def decorator(func):
+        cache = {}
+
+        def make_hashable(item):
+            if isinstance(item, dict):
+                # Exclude the 'filter[min_time]' key from the dictionary
+                item = {k: v for k, v in item.items() if k != 'filter[min_time]'}
+                return frozenset((make_hashable(k), make_hashable(v)) for k, v in item.items())
+            return str(item)  # Convert non-dict items to string
+
+        async def wrapper(*args):
+            current_time = datetime.now()
+            cache_key = tuple(make_hashable(arg) for arg in args)
+
+            if cache_key in cache:
+                cached_result, timestamp = cache[cache_key]
+
+                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}")
+                        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}")
+                        return cached_result
+
+            _LOGGER.debug(f"Cache miss for {func.__name__} with arguments {cache_key} at {current_time}")
+            result = await func(*args)
+            cache[cache_key] = (result, current_time)
+            _LOGGER.debug(f"Cache updated for key: {cache_key} at {current_time}")
+            return result
+
+        return wrapper
+    return decorator

mbtaclient-0.2.6/src/mbtaclient/trip_handler.py

@@ -0,0 +1,124 @@
+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 
+    
+    

mbtaclient-0.2.4/src/mbtaclient/mbta_utils.py

@@ -1,50 +0,0 @@
-from datetime import datetime
-from typing import Optional
-
-class MBTAUtils:
-    
-    ROUTE_TYPES= {
-        # 0: 'Light Rail',   # Example: Green Line
-        # 1: 'Heavy Rail',   # Example: Red Line
-        0: 'Subway',   
-        1: 'Subway',  
-        2: 'Commuter Rail',
-        3: 'Bus',
-        4: 'Ferry'
-    }
-
-    UNCERTAINTY = {
-        '60': 'Trip that has already started',
-        '120': 'Trip not started and a vehicle is awaiting departure at the origin',
-        '300': 'Vehicle has not yet been assigned to the trip',
-        '301': 'Vehicle appears to be stalled or significantly delayed',
-        '360': 'Trip not started and a vehicle is completing a previous trip'
-    }
-           
-    @staticmethod
-    def get_route_type_desc_by_type_id(route_type: int) -> str:
-        """Get a description of the route type."""
-        return MBTAUtils.ROUTE_TYPES.get(route_type, 'Unknown')
-    
-    @staticmethod
-    def get_uncertainty_description(key: str) -> str:
-        return MBTAUtils.UNCERTAINTY.get(key, 'None')
-    
-    @staticmethod
-    def time_to(time: Optional[datetime], now: datetime) -> Optional[float]:
-        if time is None:
-            return None
-        return (time - now).total_seconds()
-
-    @staticmethod
-    def calculate_time_difference(real_time: Optional[datetime], time: Optional[datetime]) -> Optional[float]:
-        if real_time is None or time is None:
-            return None
-        return (real_time - time).total_seconds()
-
-    @staticmethod
-    def parse_datetime(time_str: str) -> Optional[datetime]:
-        """Parse a string in ISO 8601 format to a datetime object."""
-        if not isinstance(time_str, str):
-            return None
-        return datetime.fromisoformat(time_str)

mbtaclient-0.2.4/src/mbtaclient/trip_handler.py

@@ -1,85 +0,0 @@
-import aiohttp
-import logging
-
-from base_handler import BaseHandler
-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, session: aiohttp.ClientSession, logger: logging.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 async_init(self):
-        await super()._async_init()
-
-        params = {
-            'filter[revenue]' :'REVENUE',
-            'filter[name]' : self.trip_name
-        }
-        trips: list[MBTATrip] = await super()._fetch_trips(params)
-        
-        journey = Journey()
-        journey.trip = trips[0]
-        
-        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()))
-        jounrey.trip.id
-        
-        params = {
-            'filter[trip]':  jounrey.trip.id,
-        }
-        
-        schedules = await super()._fetch_schedules(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