python-navitia-client 1.2.2__tar.gz → 1.3.0__tar.gz

{python_navitia_client-1.2.2/python_navitia_client.egg-info → python_navitia_client-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-navitia-client
-Version: 1.2.2
+Version: 1.3.0
 Summary: Python library to use with Navitia APIs
 Author-email: Jonathan Perron <jonathan@perron.bzh>
 License: MIT License
@@ -52,15 +52,16 @@ The library supports the following [APIs](https://doc.navitia.io/#api-catalog):
 | Autocomplete on geographical objects      | ✅           |                                              |
 | Places nearby                             | ✅           |                                              |
 | Journeys                                  | ✅           |                                              |
-| Isochrones                                | ✅           | Beta endpoint according to API response      |
+| Isochrones                                | ✅           |                                              |
 | Route Schedules                           | ✅           |                                              |
 | Stop Schedules                            | ✅           |                                              |
 | Terminus Schedules                        | ✅           |                                              |
 | Departures                                | ✅           |                                              |
 | Arrivals                                  | ✅           |                                              |
-| Line reports                              | ✅           | Beta endpoint according to API response      |
-| Traffic reports                           | ✅           | Beta endpoint according to API response      |
-| Equipment reports                         | ❌           | Beta service, not available to all providers |
+| Line reports                              | ✅           |                                              |
+| Traffic reports                           | ✅           |                                              |
+| Equipment reports                         | ✅           | Not available to all providers               |
+| Freefloating nearby                       | ✅           | Not available to all providers               |
 
 ## Usage
 

{python_navitia_client-1.2.2 → python_navitia_client-1.3.0}/README.md

@@ -33,15 +33,16 @@ The library supports the following [APIs](https://doc.navitia.io/#api-catalog):
 | Autocomplete on geographical objects      | ✅           |                                              |
 | Places nearby                             | ✅           |                                              |
 | Journeys                                  | ✅           |                                              |
-| Isochrones                                | ✅           | Beta endpoint according to API response      |
+| Isochrones                                | ✅           |                                              |
 | Route Schedules                           | ✅           |                                              |
 | Stop Schedules                            | ✅           |                                              |
 | Terminus Schedules                        | ✅           |                                              |
 | Departures                                | ✅           |                                              |
 | Arrivals                                  | ✅           |                                              |
-| Line reports                              | ✅           | Beta endpoint according to API response      |
-| Traffic reports                           | ✅           | Beta endpoint according to API response      |
-| Equipment reports                         | ❌           | Beta service, not available to all providers |
+| Line reports                              | ✅           |                                              |
+| Traffic reports                           | ✅           |                                              |
+| Equipment reports                         | ✅           | Not available to all providers               |
+| Freefloating nearby                       | ✅           | Not available to all providers               |
 
 ## Usage
 

{python_navitia_client-1.2.2 → python_navitia_client-1.3.0}/navitia_client/client/apis/arrival_apis.py

@@ -80,6 +80,8 @@ class ArrivalApiClient(ApiBaseClient):
         from_datetime: datetime = datetime.now(),
         duration: int = 86400,
         depth: int = 1,
+        count: int = 10,
+        start_page: int = 0,
         forbidden_uris: Optional[Sequence[str]] = None,
         data_freshness: str = "realtime",
         disable_geojson: bool = False,
@@ -100,6 +102,10 @@ class ArrivalApiClient(ApiBaseClient):
             The duration in seconds for which to fetch arrivals (default is 86400 seconds).
         depth : int, optional
             The depth of the search (default is 1).
+        count : int, optional
+            Maximum number of results (default is 10).
+        start_page : int, optional
+            The page number to start from (default is 0).
         forbidden_uris : Optional[Sequence[str]], optional
             A list of URIs to exclude from the search (default is None).
         data_freshness : str, optional
@@ -120,6 +126,8 @@ class ArrivalApiClient(ApiBaseClient):
             "from_datetime": from_datetime,
             "duration": duration,
             "depth": depth,
+            "count": count,
+            "start_page": start_page,
             "disable_geojson": disable_geojson,
             "forbidden_uris[]": forbidden_uris,
             "data_freshness": data_freshness,
@@ -137,6 +145,8 @@ class ArrivalApiClient(ApiBaseClient):
         from_datetime: datetime = datetime.now(),
         duration: int = 86400,
         depth: int = 1,
+        count: int = 10,
+        start_page: int = 0,
         forbidden_uris: Optional[Sequence[str]] = None,
         data_freshness: str = "realtime",
         disable_geojson: bool = False,
@@ -161,6 +171,10 @@ class ArrivalApiClient(ApiBaseClient):
             The duration in seconds for which to fetch arrivals (default is 86400 seconds).
         depth : int, optional
             The depth of the search (default is 1).
+        count : int, optional
+            Maximum number of results (default is 10).
+        start_page : int, optional
+            The page number to start from (default is 0).
         forbidden_uris : Optional[Sequence[str]], optional
             A list of URIs to exclude from the search (default is None).
         data_freshness : str, optional
@@ -182,6 +196,8 @@ class ArrivalApiClient(ApiBaseClient):
             "from_datetime": from_datetime,
             "duration": duration,
             "depth": depth,
+            "count": count,
+            "start_page": start_page,
             "disable_geojson": disable_geojson,
             "forbidden_uris[]": forbidden_uris,
             "data_freshness": data_freshness,

{python_navitia_client-1.2.2 → python_navitia_client-1.3.0}/navitia_client/client/apis/departure_apis.py

@@ -101,6 +101,8 @@ class DepartureApiClient(ApiBaseClient):
         from_datetime: datetime = datetime.now(),
         duration: int = 86400,
         depth: int = 1,
+        count: int = 10,
+        start_page: int = 0,
         forbidden_uris: Optional[Sequence[str]] = None,
         data_freshness: str = "realtime",
         disable_geojson: bool = False,
@@ -121,6 +123,10 @@ class DepartureApiClient(ApiBaseClient):
             The duration for which to fetch departures, in seconds (default is 86400 seconds, i.e., 1 day).
         depth : int, optional
             The depth of the search (default is 1).
+        count : int, optional
+            Maximum number of results (default is 10).
+        start_page : int, optional
+            The page number to start from (default is 0).
         forbidden_uris : Optional[Sequence[str]], optional
             A list of URIs to exclude from the search (default is None).
         data_freshness : str, optional
@@ -141,6 +147,8 @@ class DepartureApiClient(ApiBaseClient):
             "from_datetime": from_datetime,
             "duration": duration,
             "depth": depth,
+            "count": count,
+            "start_page": start_page,
             "disable_geojson": disable_geojson,
             "forbidden_uris[]": forbidden_uris,
             "data_freshness": data_freshness,
@@ -158,6 +166,8 @@ class DepartureApiClient(ApiBaseClient):
         from_datetime: datetime = datetime.now(),
         duration: int = 86400,
         depth: int = 1,
+        count: int = 10,
+        start_page: int = 0,
         forbidden_uris: Optional[Sequence[str]] = None,
         data_freshness: str = "realtime",
         disable_geojson: bool = False,
@@ -182,6 +192,10 @@ class DepartureApiClient(ApiBaseClient):
             The duration for which to fetch departures, in seconds (default is 86400 seconds, i.e., 1 day).
         depth : int, optional
             The depth of the search (default is 1).
+        count : int, optional
+            Maximum number of results (default is 10).
+        start_page : int, optional
+            The page number to start from (default is 0).
         forbidden_uris : Optional[Sequence[str]], optional
             A list of URIs to exclude from the search (default is None).
         data_freshness : str, optional
@@ -202,6 +216,8 @@ class DepartureApiClient(ApiBaseClient):
             "from_datetime": from_datetime,
             "duration": duration,
             "depth": depth,
+            "count": count,
+            "start_page": start_page,
             "disable_geojson": disable_geojson,
             "forbidden_uris[]": forbidden_uris,
             "data_freshness": data_freshness,

python_navitia_client-1.3.0/navitia_client/client/apis/equipment_report_apis.py

@@ -0,0 +1,153 @@
+from typing import Optional, Sequence, Tuple
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.equipment_reports import EquipmentReports
+from navitia_client.entities.pagination import Pagination
+
+
+class EquipmentReportsApiClient(ApiBaseClient):
+    """
+    A client class to interact with the Navitia API for fetching equipment reports.
+
+    See https://doc.navitia.io/#equipment-reports
+
+    Methods
+    -------
+    _get_equipment_reports(
+        url: str, filters: dict
+    ) -> Tuple[Sequence[EquipmentReports], Pagination]:
+        Retrieves equipment reports from the Navitia API based on provided URL and filters.
+
+    list_equipment_reports(
+        region_id: str,
+        count: int = 10,
+        depth: int = 1,
+        filter: Optional[str] = None,
+        forbidden_uris: Optional[Sequence[str]] = None,
+        start_page: int = 0,
+    ) -> Tuple[Sequence[EquipmentReports], Pagination]:
+        Retrieves equipment reports for a specified region from the Navitia API.
+
+    list_equipment_reports_with_resource_path(
+        region_id: str,
+        resource_path: str,
+        count: int = 10,
+        depth: int = 1,
+        filter: Optional[str] = None,
+        forbidden_uris: Optional[Sequence[str]] = None,
+        start_page: int = 0,
+    ) -> Tuple[Sequence[EquipmentReports], Pagination]:
+        Retrieves equipment reports for a specific resource path in a region from the Navitia API.
+    """
+
+    def _get_equipment_reports(
+        self, url: str, filters: dict
+    ) -> Tuple[Sequence[EquipmentReports], Pagination]:
+        """
+        Retrieves equipment reports from the Navitia API based on provided URL and filters.
+
+        Parameters:
+            url (str): The URL for the API request.
+            filters (dict): Filters to apply to the API request.
+
+        Returns:
+            Tuple[Sequence[EquipmentReports], Pagination]: A tuple containing sequences of EquipmentReports objects and Pagination object.
+        """
+        results = self.get_navitia_api(url + self._generate_filter_query(filters))
+        equipment_reports = [
+            EquipmentReports.from_payload(data)
+            for data in results.json()["equipment_reports"]
+        ]
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return equipment_reports, pagination
+
+    def list_equipment_reports(
+        self,
+        region_id: str,
+        count: int = 10,
+        depth: int = 1,
+        filter: Optional[str] = None,
+        forbidden_uris: Optional[Sequence[str]] = None,
+        start_page: int = 0,
+    ) -> Tuple[Sequence[EquipmentReports], Pagination]:
+        """
+        Retrieves equipment reports for a specified region from the Navitia API.
+
+        This service provides the state of equipments such as lifts or elevators that
+        are giving better accessibility to public transport facilities.
+        The endpoint will report accessible equipment per stop area and per line.
+
+        Parameters:
+            region_id (str): The region ID (coverage identifier).
+            count (int): Elements per page. Defaults to 10.
+            depth (int): Json response depth. Defaults to 1.
+            filter (Optional[str]): A filter to refine your request (e.g., 'line.code=A').
+            forbidden_uris (Optional[Sequence[str]]): If you want to avoid lines, modes, networks, etc.
+            start_page (int): The page number. Defaults to 0.
+
+        Returns:
+            Tuple[Sequence[EquipmentReports], Pagination]: A tuple containing sequences of EquipmentReports objects and Pagination object.
+
+        Note:
+            This feature requires a specific configuration from an equipment service provider.
+            Therefore, this service is not available by default.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{region_id}/equipment_reports"
+
+        filters = {
+            "count": count,
+            "depth": depth,
+            "start_page": start_page,
+            "forbidden_uris[]": forbidden_uris,
+        }
+
+        if filter:
+            filters["filter"] = filter
+
+        return self._get_equipment_reports(request_url, filters)
+
+    def list_equipment_reports_with_resource_path(
+        self,
+        region_id: str,
+        resource_path: str,
+        count: int = 10,
+        depth: int = 1,
+        filter: Optional[str] = None,
+        forbidden_uris: Optional[Sequence[str]] = None,
+        start_page: int = 0,
+    ) -> Tuple[Sequence[EquipmentReports], Pagination]:
+        """
+        Retrieves equipment reports for a specific resource path in a region from the Navitia API.
+
+        This service provides the state of equipments such as lifts or elevators that
+        are giving better accessibility to public transport facilities.
+        The endpoint will report accessible equipment per stop area and per line.
+
+        Parameters:
+            region_id (str): The region ID (coverage identifier).
+            resource_path (str): The resource path (e.g., 'lines/line:A').
+            count (int): Elements per page. Defaults to 10.
+            depth (int): Json response depth. Defaults to 1.
+            filter (Optional[str]): A filter to refine your request (e.g., 'line.code=A').
+            forbidden_uris (Optional[Sequence[str]]): If you want to avoid lines, modes, networks, etc.
+            start_page (int): The page number. Defaults to 0.
+
+        Returns:
+            Tuple[Sequence[EquipmentReports], Pagination]: A tuple containing sequences of EquipmentReports objects and Pagination object.
+
+        Note:
+            This feature requires a specific configuration from an equipment service provider.
+            Therefore, this service is not available by default.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{region_id}/{resource_path}/equipment_reports"
+
+        filters = {
+            "count": count,
+            "depth": depth,
+            "start_page": start_page,
+            "forbidden_uris[]": forbidden_uris,
+        }
+
+        if filter:
+            filters["filter"] = filter
+
+        return self._get_equipment_reports(request_url, filters)

python_navitia_client-1.3.0/navitia_client/client/apis/freefloatings_nearby_apis.py

@@ -0,0 +1,247 @@
+from typing import Any, Dict, Optional, Sequence, Tuple
+
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.free_floating import FreeFloating
+from navitia_client.entities.pagination import Pagination
+
+
+class FreefloatingsNearbyApiClient(ApiBaseClient):
+    """
+    A client class to interact with the Navitia API for fetching nearby free-floating vehicles.
+
+    See https://doc.navitia.io/#freefloatings-nearby-api
+
+    Methods
+    -------
+    _get_freefloatings_nearby(
+        url: str, filters: dict
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        Retrieves free-floating vehicles from the Navitia API based on provided URL and filters.
+
+    list_freefloatings_nearby(
+        region_id: str,
+        lon: float,
+        lat: float,
+        distance: int = 500,
+        type: Optional[Sequence[str]] = None,
+        count: int = 10,
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        Retrieves free-floating vehicles near coordinates in a specific region from the Navitia API.
+
+    list_freefloatings_nearby_with_resource_path(
+        region_id: str,
+        resource_path: str,
+        distance: int = 500,
+        type: Optional[Sequence[str]] = None,
+        count: int = 10,
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        Retrieves free-floating vehicles near a specific resource path in a region from the Navitia API.
+
+    list_freefloatings_nearby_by_coordinates(
+        region_lon: float,
+        region_lat: float,
+        lon: float,
+        lat: float,
+        distance: int = 500,
+        type: Optional[Sequence[str]] = None,
+        count: int = 10,
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        Retrieves free-floating vehicles near coordinates, navitia guesses the region from coordinates.
+
+    list_freefloatings_nearby_by_coordinates_only(
+        lon: float,
+        lat: float,
+        distance: int = 500,
+        type: Optional[Sequence[str]] = None,
+        count: int = 10,
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        Retrieves free-floating vehicles near coordinates without any region id.
+    """
+
+    def _get_freefloatings_nearby(
+        self, url: str, filters: dict
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        """
+        Retrieves free-floating vehicles from the Navitia API based on provided URL and filters.
+
+        Parameters:
+            url (str): The URL for the API request.
+            filters (dict): Filters to apply to the API request.
+
+        Returns:
+            Tuple[Sequence[FreeFloating], Pagination]: A tuple containing sequences of FreeFloating objects and Pagination object.
+        """
+        results = self.get_navitia_api(url + self._generate_filter_query(filters))
+        free_floatings = [
+            FreeFloating.from_payload(data) for data in results.json()["free_floatings"]
+        ]
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return free_floatings, pagination
+
+    def list_freefloatings_nearby(
+        self,
+        region_id: str,
+        lon: float,
+        lat: float,
+        distance: int = 500,
+        type: Optional[Sequence[str]] = None,
+        count: int = 10,
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        """
+        Retrieves free-floating vehicles near coordinates in a specific region from the Navitia API.
+
+        This service provides access to nearby shared mobility options (such as bikes,
+        scooters, or cars) based on user-provided coordinates.
+
+        Parameters:
+            region_id (str): The region ID (coverage identifier).
+            lon (float): The longitude coordinate.
+            lat (float): The latitude coordinate.
+            distance (int): Search radius in meters. Defaults to 500.
+            type (Optional[Sequence[str]]): The type of shared mobility vehicles to return (e.g., bike, scooter, car).
+            count (int): Maximum number of results to return. Defaults to 10.
+
+        Returns:
+            Tuple[Sequence[FreeFloating], Pagination]: A tuple containing sequences of FreeFloating objects and Pagination object.
+
+        Note:
+            This feature requires a specific configuration from a freefloating data service provider.
+            Therefore, this service is not available by default.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{region_id}/coords/{lon};{lat}/freefloatings_nearby"
+
+        filters: Dict[str, Any] = {
+            "distance": distance,
+            "count": count,
+        }
+
+        if type:
+            filters["type[]"] = type
+
+        return self._get_freefloatings_nearby(request_url, filters)
+
+    def list_freefloatings_nearby_with_resource_path(
+        self,
+        region_id: str,
+        resource_path: str,
+        distance: int = 500,
+        type: Optional[Sequence[str]] = None,
+        count: int = 10,
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        """
+        Retrieves free-floating vehicles near a specific resource path in a region from the Navitia API.
+
+        This service provides access to nearby shared mobility options (such as bikes,
+        scooters, or cars) near a specific resource (stop area, address, etc.).
+
+        Parameters:
+            region_id (str): The region ID (coverage identifier).
+            resource_path (str): The resource path (e.g., 'stop_areas/stop_area:XXX').
+            distance (int): Search radius in meters. Defaults to 500.
+            type (Optional[Sequence[str]]): The type of shared mobility vehicles to return (e.g., bike, scooter, car).
+            count (int): Maximum number of results to return. Defaults to 10.
+
+        Returns:
+            Tuple[Sequence[FreeFloating], Pagination]: A tuple containing sequences of FreeFloating objects and Pagination object.
+
+        Note:
+            This feature requires a specific configuration from a freefloating data service provider.
+            Therefore, this service is not available by default.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{region_id}/{resource_path}/freefloatings_nearby"
+
+        filters: Dict[str, Any] = {
+            "distance": distance,
+            "count": count,
+        }
+
+        if type:
+            filters["type[]"] = type
+
+        return self._get_freefloatings_nearby(request_url, filters)
+
+    def list_freefloatings_nearby_by_coordinates(
+        self,
+        region_lon: float,
+        region_lat: float,
+        lon: float,
+        lat: float,
+        distance: int = 500,
+        type: Optional[Sequence[str]] = None,
+        count: int = 10,
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        """
+        Retrieves free-floating vehicles near coordinates, navitia guesses the region from coordinates.
+
+        This service provides access to nearby shared mobility options (such as bikes,
+        scooters, or cars) based on user-provided coordinates. Navitia will automatically
+        determine the region based on the provided region coordinates.
+
+        Parameters:
+            region_lon (float): The longitude coordinate for region identification.
+            region_lat (float): The latitude coordinate for region identification.
+            lon (float): The longitude coordinate for the search center.
+            lat (float): The latitude coordinate for the search center.
+            distance (int): Search radius in meters. Defaults to 500.
+            type (Optional[Sequence[str]]): The type of shared mobility vehicles to return (e.g., bike, scooter, car).
+            count (int): Maximum number of results to return. Defaults to 10.
+
+        Returns:
+            Tuple[Sequence[FreeFloating], Pagination]: A tuple containing sequences of FreeFloating objects and Pagination object.
+
+        Note:
+            This feature requires a specific configuration from a freefloating data service provider.
+            Therefore, this service is not available by default.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{region_lon};{region_lat}/coords/{lon};{lat}/freefloatings_nearby"
+
+        filters: Dict[str, Any] = {
+            "distance": distance,
+            "count": count,
+        }
+
+        if type:
+            filters["type[]"] = type
+
+        return self._get_freefloatings_nearby(request_url, filters)
+
+    def list_freefloatings_nearby_by_coordinates_only(
+        self,
+        lon: float,
+        lat: float,
+        distance: int = 500,
+        type: Optional[Sequence[str]] = None,
+        count: int = 10,
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        """
+        Retrieves free-floating vehicles near coordinates without any region id.
+
+        This service provides access to nearby shared mobility options (such as bikes,
+        scooters, or cars) based on user-provided coordinates. This method does not require
+        a region ID; Navitia will automatically determine the appropriate region.
+
+        Parameters:
+            lon (float): The longitude coordinate.
+            lat (float): The latitude coordinate.
+            distance (int): Search radius in meters. Defaults to 500.
+            type (Optional[Sequence[str]]): The type of shared mobility vehicles to return (e.g., bike, scooter, car).
+            count (int): Maximum number of results to return. Defaults to 10.
+
+        Returns:
+            Tuple[Sequence[FreeFloating], Pagination]: A tuple containing sequences of FreeFloating objects and Pagination object.
+
+        Note:
+            This feature requires a specific configuration from a freefloating data service provider.
+            Therefore, this service is not available by default.
+        """
+        request_url = f"{self.base_navitia_url}/coord/{lon};{lat}/freefloatings_nearby"
+
+        filters: Dict[str, Any] = {
+            "distance": distance,
+            "count": count,
+        }
+
+        if type:
+            filters["type[]"] = type
+
+        return self._get_freefloatings_nearby(request_url, filters)