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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-navitia-client
-Version: 1.3.0
+Version: 2.0.0
 Summary: Python library to use with Navitia APIs
 Author-email: Jonathan Perron <jonathan@perron.bzh>
 License: MIT License

python_navitia_client-2.0.0/navitia_client/client/apis/arrival_apis.py

@@ -0,0 +1,95 @@
+from typing import Any, Sequence, Tuple
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.request.arrival import ArrivalRequest
+from navitia_client.entities.response import Pagination
+from navitia_client.entities.response.arrival import Arrival
+
+
+class ArrivalApiClient(ApiBaseClient):
+    """Client class to interact with the Navitia API for fetching arrival information.
+
+    See https://doc.navitia.io/#arrivals
+    """
+
+    @staticmethod
+    def _get_arrival_objects_from_response(
+        response: Any,
+    ) -> Sequence[Arrival]:
+        """Convert raw response data into a list of Arrival objects.
+
+        Args:
+            response: The raw response data from the API containing arrivals' information.
+
+        Returns:
+            A list of Arrival objects created from the raw response data.
+        """
+
+        arrivals = []
+        for arrival_data in response:
+            arrivals.append(Arrival.from_payload(arrival_data))
+
+        return arrivals
+
+    def _get_arrivals(
+        self, url: str, filters: dict
+    ) -> Tuple[Sequence[Arrival], Pagination]:
+        """Fetch arrivals based on a given URL and filters.
+
+        Args:
+            url: The URL for the API request.
+            filters: The filters to apply to the API request.
+
+        Returns:
+            A tuple containing a list of Arrival objects and a Pagination object for managing result pages.
+        """
+        results = self.get_navitia_api(url + self._generate_filter_query(filters))
+        raw_results = results.json()["arrivals"]
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return self._get_arrival_objects_from_response(raw_results), pagination
+
+    def list_arrivals_by_region_id_and_path(
+        self,
+        region_id: str,
+        resource_path: str,
+        request: ArrivalRequest,
+    ) -> Tuple[Sequence[Arrival], Pagination]:
+        """Retrieve a list of arrivals for a specific region and resource path.
+
+        Args:
+            region_id: The identifier of the region to fetch arrivals from.
+            resource_path: The resource path within the region to fetch arrivals for.
+            request: The ArrivalRequest containing filters and parameters for the query.
+
+        Returns:
+            A tuple containing a list of Arrival objects and a Pagination object for managing result pages.
+        """
+        request_url = (
+            f"{self.base_navitia_url}/coverage/{region_id}/{resource_path}/arrivals"
+        )
+
+        return self._get_arrivals(request_url, request.to_filters())
+
+    def list_arrivals_by_coordinates(
+        self,
+        region_lon: float,
+        region_lat: float,
+        lon: float,
+        lat: float,
+        request: ArrivalRequest,
+    ) -> Tuple[Sequence[Arrival], Pagination]:
+        """Retrieve a list of arrivals for specific coordinates.
+
+        Args:
+            region_lon: The longitude of the region to fetch arrivals from.
+            region_lat: The latitude of the region to fetch arrivals from.
+            lon: The longitude of the specific location to fetch arrivals for.
+            lat: The latitude of the specific location to fetch arrivals for.
+            request: The ArrivalRequest containing filters and parameters for the query.
+
+        Returns:
+            A tuple containing a list of Arrival objects and a Pagination object for managing result pages.
+        """
+        # List of objects near the resource, navitia guesses the region from coordinates
+        request_url = f"{self.base_navitia_url}/coverage/{region_lon};{region_lat}/coords/{lon};{lat}/arrivals"
+
+        return self._get_arrivals(request_url, request.to_filters())

python_navitia_client-2.0.0/navitia_client/client/apis/contributors_apis.py

@@ -0,0 +1,76 @@
+from typing import Any, Sequence, Tuple
+
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.request.contributor import ContributorRequest
+from navitia_client.entities.response.contributor import Contributor
+from navitia_client.entities.response import Pagination
+
+
+class ContributorsApiClient(ApiBaseClient):
+    """Client class to interact with the Navitia API for fetching contributors.
+
+    See https://doc.navitia.io/#contributors
+    """
+
+    @staticmethod
+    def _get_contributors_from_response(
+        raw_contributors_response: Any,
+    ) -> Sequence[Contributor]:
+        """Convert raw response data into a list of Contributor objects.
+
+        Args:
+            raw_contributors_response: The raw response data from the API containing contributors' information.
+
+        Returns:
+            A list of Contributor objects created from the raw response data.
+        """
+        contributors = []
+        for contributor_data in raw_contributors_response:
+            contributors.append(Contributor.from_payload(contributor_data))
+
+        return contributors
+
+    def list_contributors(
+        self, region_id: str, request: ContributorRequest
+    ) -> Tuple[Sequence[Contributor], Pagination]:
+        """Retrieve a list of contributors for a specific region.
+
+        Args:
+            region_id: The identifier of the region to fetch contributors from.
+            request: The request object containing query parameters.
+
+        Returns:
+            A tuple containing a list of Contributor objects and a Pagination object for managing result pages.
+        """
+        url = f"{self.base_navitia_url}/coverage/{region_id}/contributors"
+        results = self.get_navitia_api(
+            url + self._generate_filter_query(request.to_filters())
+        )
+        raw_results = results.json()["contributors"]
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return ContributorsApiClient._get_contributors_from_response(
+            raw_results
+        ), pagination
+
+    def get_contributor_on_dataset(
+        self, region_id: str, dataset_id: str, request: ContributorRequest
+    ) -> Tuple[Sequence[Contributor], Pagination]:
+        """Retrieve a list of contributors for a specific dataset in a region.
+
+        Args:
+            region_id: The identifier of the region to fetch contributors from.
+            dataset_id: The identifier of the dataset to fetch contributors for.
+            request: The request object containing query parameters.
+
+        Returns:
+            A tuple containing a list of Contributor objects and a Pagination object for managing result pages.
+        """
+        url = f"{self.base_navitia_url}/coverage/{region_id}/contributors/{dataset_id}"
+        results = self.get_navitia_api(
+            url + self._generate_filter_query(request.to_filters())
+        )
+        raw_results = results.json()["contributors"]
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return ContributorsApiClient._get_contributors_from_response(
+            raw_results
+        ), pagination

python_navitia_client-2.0.0/navitia_client/client/apis/coverage_apis.py

@@ -0,0 +1,91 @@
+from typing import Any, Sequence, Tuple
+
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.request.coverage import CoverageRequest
+from navitia_client.entities.response.administrative_region import Region
+from navitia_client.entities.response import Pagination
+
+
+class CoverageApiClient(ApiBaseClient):
+    """Client class to interact with the Navitia API for fetching coverage area information.
+
+    See https://doc.navitia.io/#coverage
+    """
+
+    @staticmethod
+    def _get_regions_from_response(raw_regions_response: Any) -> Sequence[Region]:
+        """Convert raw response data into a list of Region objects.
+
+        Args:
+            raw_regions_response: The raw response data from the API containing regions' information.
+
+        Returns:
+            A list of Region objects created from the raw response data.
+        """
+        regions = []
+        for region_data in raw_regions_response:
+            regions.append(Region.from_payload(region_data))
+        return regions
+
+    def list_covered_areas(
+        self, request: CoverageRequest
+    ) -> Tuple[Sequence[Region], Pagination]:
+        """Retrieve a list of covered areas from the Navitia API.
+
+        Args:
+            request: The request object containing query parameters.
+
+        Returns:
+            A tuple containing a list of Region objects and a Pagination object for managing result pages.
+        """
+        url = f"{self.base_navitia_url}/coverage"
+        results = self.get_navitia_api(
+            url + self._generate_filter_query(request.to_filters())
+        )
+        result_regions = results.json()["regions"]
+        regions = CoverageApiClient._get_regions_from_response(result_regions)
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return regions, pagination
+
+    def get_coverage_by_region_id(
+        self, region_id: str, request: CoverageRequest
+    ) -> Tuple[Sequence[Region], Pagination]:
+        """Retrieve information about a specific region by its ID.
+
+        Args:
+            region_id: The identifier of the region to fetch information about.
+            request: The request object containing query parameters.
+
+        Returns:
+            A tuple containing a list of Region objects and a Pagination object for managing result pages.
+        """
+        url = f"{self.base_navitia_url}/coverage/{region_id}"
+        results = self.get_navitia_api(
+            url + self._generate_filter_query(request.to_filters())
+        )
+        result_regions = results.json()["regions"]
+        regions = CoverageApiClient._get_regions_from_response(result_regions)
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return regions, pagination
+
+    def get_coverage_by_region_coordinates_and_coordinates(
+        self, lon: float, lat: float, request: CoverageRequest
+    ) -> Tuple[Sequence[Region], Pagination]:
+        """Retrieve information about a region based on coordinates.
+
+        Args:
+            lon: The longitude of the location to fetch information about.
+            lat: The latitude of the location to fetch information about.
+            request: The request object containing query parameters.
+
+        Returns:
+            A tuple containing a list of Region objects and a Pagination object for managing result pages.
+        """
+        url = f"{self.base_navitia_url}/coverage/{lon};{lat}"
+        results = self.get_navitia_api(
+            url + self._generate_filter_query(request.to_filters())
+        )
+        result_regions = results.json()["regions"]
+        regions = CoverageApiClient._get_regions_from_response(result_regions)
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return regions, pagination

python_navitia_client-2.0.0/navitia_client/client/apis/datasets_apis.py

@@ -0,0 +1,74 @@
+from typing import Any, Sequence, Tuple
+
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.request.dataset import DatasetRequest
+from navitia_client.entities.response.dataset import Dataset
+from navitia_client.entities.response import Pagination
+
+
+class DatasetsApiClient(ApiBaseClient):
+    """Client class to interact with the Navitia API for fetching dataset information.
+
+    See https://doc.navitia.io/#datasets
+    """
+
+    @staticmethod
+    def _get_datasets_from_response(raw_datasets_response: Any) -> Sequence[Dataset]:
+        """Convert raw response data into a list of Dataset objects.
+
+        Args:
+            raw_datasets_response: The raw response data from the API containing datasets' information.
+
+        Returns:
+            A list of Dataset objects created from the raw response data.
+        """
+        datasets = []
+        for dataset in raw_datasets_response:
+            dataset_contributor = dataset.get("contributor")
+            if not dataset_contributor:
+                continue
+
+            datasets.append(Dataset.from_payload(dataset))
+
+        return datasets
+
+    def list_datasets(
+        self, region_id: str, request: DatasetRequest
+    ) -> Tuple[Sequence[Dataset], Pagination]:
+        """Retrieve a list of datasets for a specified region from the Navitia API.
+
+        Args:
+            region_id: The identifier of the region to fetch datasets from.
+            request: The request object containing query parameters.
+
+        Returns:
+            A tuple containing a list of Dataset objects and a Pagination object for managing result pages.
+        """
+        url = f"{self.base_navitia_url}/coverage/{region_id}/datasets"
+        results = self.get_navitia_api(
+            url + self._generate_filter_query(request.to_filters())
+        )
+        raw_results = results.json()["datasets"]
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return DatasetsApiClient._get_datasets_from_response(raw_results), pagination
+
+    def get_dataset_by_id(
+        self, region_id: str, dataset_id: str, request: DatasetRequest
+    ) -> Tuple[Sequence[Dataset], Pagination]:
+        """Retrieve information about a specific dataset by its ID within a region.
+
+        Args:
+            region_id: The identifier of the region to fetch the dataset from.
+            dataset_id: The identifier of the dataset to fetch.
+            request: The request object containing query parameters.
+
+        Returns:
+            A tuple containing a list of Dataset objects and a Pagination object for managing result pages.
+        """
+        url = f"{self.base_navitia_url}/coverage/{region_id}/datasets/{dataset_id}"
+        results = self.get_navitia_api(
+            url + self._generate_filter_query(request.to_filters())
+        )
+        raw_results = results.json()["datasets"]
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return DatasetsApiClient._get_datasets_from_response(raw_results), pagination

python_navitia_client-2.0.0/navitia_client/client/apis/departure_apis.py

@@ -0,0 +1,93 @@
+from typing import Any, Sequence, Tuple
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.request.departure import DepartureRequest
+from navitia_client.entities.response import Pagination
+from navitia_client.entities.response.departure import Departure
+
+
+class DepartureApiClient(ApiBaseClient):
+    """Client for interacting with the Navitia API to retrieve departure schedules.
+
+    See https://doc.navitia.io/#departures
+    """
+
+    @staticmethod
+    def _get_departure_objects_from_response(
+        response: Any,
+    ) -> Sequence[Departure]:
+        """Convert raw response data into a list of Departure objects.
+
+        Args:
+            response: The raw response data from the API containing departures' information.
+
+        Returns:
+            A list of Departure objects created from the raw response data.
+        """
+        departures = []
+        for departure_data in response:
+            departures.append(Departure.from_payload(departure_data))
+
+        return departures
+
+    def _get_departures(
+        self, url: str, filters: dict
+    ) -> Tuple[Sequence[Departure], Pagination]:
+        """Fetch departures from the Navitia API based on the provided URL and filters.
+
+        Args:
+            url: The URL to fetch departures from.
+            filters: A dictionary of filters to apply to the query.
+
+        Returns:
+            A tuple containing a list of Departure objects and a Pagination object for managing result pages.
+        """
+        results = self.get_navitia_api(url + self._generate_filter_query(filters))
+        raw_results = results.json()["departures"]
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return self._get_departure_objects_from_response(raw_results), pagination
+
+    def list_departures_by_region_id_and_path(
+        self,
+        region_id: str,
+        resource_path: str,
+        request: DepartureRequest,
+    ) -> Tuple[Sequence[Departure], Pagination]:
+        """Retrieve a list of departures for a specified region and resource path.
+
+        Args:
+            region_id: The identifier of the region to fetch departures from.
+            resource_path: The resource path to fetch departures for.
+            request: The request object containing query parameters.
+
+        Returns:
+            A tuple containing a list of Departure objects and a Pagination object for managing result pages.
+        """
+        request_url = (
+            f"{self.base_navitia_url}/coverage/{region_id}/{resource_path}/departures"
+        )
+
+        return self._get_departures(request_url, request.to_filters())
+
+    def list_departures_by_coordinates(
+        self,
+        region_lon: float,
+        region_lat: float,
+        lon: float,
+        lat: float,
+        request: DepartureRequest,
+    ) -> Tuple[Sequence[Departure], Pagination]:
+        """Retrieve a list of departures for a specified region and coordinates.
+
+        Args:
+            region_lon: The longitude of the region.
+            region_lat: The latitude of the region.
+            lon: The longitude of the specific location.
+            lat: The latitude of the specific location.
+            request: The request object containing query parameters.
+
+        Returns:
+            A tuple containing a list of Departure objects and a Pagination object for managing result pages.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{region_lon};{region_lat}/coords/{lon};{lat}/departures"
+
+        return self._get_departures(request_url, request.to_filters())

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

@@ -0,0 +1,84 @@
+from typing import Sequence, Tuple
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.request.equipment_report import EquipmentReportRequest
+from navitia_client.entities.response.equipment_reports import EquipmentReports
+from navitia_client.entities.response import Pagination
+
+
+class EquipmentReportsApiClient(ApiBaseClient):
+    """Client class to interact with the Navitia API for fetching equipment reports.
+
+    See https://doc.navitia.io/#equipment-reports
+    """
+
+    def _get_equipment_reports(
+        self, url: str, filters: dict
+    ) -> Tuple[Sequence[EquipmentReports], Pagination]:
+        """Retrieve equipment reports from the Navitia API based on provided URL and filters.
+
+        Args:
+            url: The URL for the API request.
+            filters: Filters to apply to the API request.
+
+        Returns:
+            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,
+        request: EquipmentReportRequest,
+    ) -> Tuple[Sequence[EquipmentReports], Pagination]:
+        """Retrieve 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.
+
+        Args:
+            region_id: The region ID (coverage identifier).
+            request: The request object containing query parameters.
+
+        Returns:
+            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"
+        return self._get_equipment_reports(request_url, request.to_filters())
+
+    def list_equipment_reports_with_resource_path(
+        self,
+        region_id: str,
+        resource_path: str,
+        request: EquipmentReportRequest,
+    ) -> Tuple[Sequence[EquipmentReports], Pagination]:
+        """Retrieve equipment reports for a specific resource path in a region.
+
+        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.
+
+        Args:
+            region_id: The region ID (coverage identifier).
+            resource_path: The resource path (e.g., 'lines/line:A').
+            request: The request object containing query parameters.
+
+        Returns:
+            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"
+        return self._get_equipment_reports(request_url, request.to_filters())

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

@@ -0,0 +1,146 @@
+from typing import Sequence, Tuple
+
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.request.freefloatings_nearby import (
+    FreefloatingsNearbyRequest,
+)
+from navitia_client.entities.response.free_floating import FreeFloating
+from navitia_client.entities.response import Pagination
+
+
+class FreefloatingsNearbyApiClient(ApiBaseClient):
+    """Client class to interact with the Navitia API for fetching nearby free-floating vehicles.
+
+    See https://doc.navitia.io/#freefloatings-nearby-api
+    """
+
+    def _get_freefloatings_nearby(
+        self, url: str, filters: dict
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        """Retrieve free-floating vehicles from the Navitia API based on provided URL and filters.
+
+        Args:
+            url: The URL for the API request.
+            filters: Filters to apply to the API request.
+
+        Returns:
+            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,
+        request: FreefloatingsNearbyRequest,
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        """Retrieve free-floating vehicles near coordinates in a specific region.
+
+        This service provides access to nearby shared mobility options (such as bikes,
+        scooters, or cars) based on user-provided coordinates.
+
+        Args:
+            region_id: The region ID (coverage identifier).
+            lon: The longitude coordinate.
+            lat: The latitude coordinate.
+            request: The request object containing query parameters.
+
+        Returns:
+            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"
+        return self._get_freefloatings_nearby(request_url, request.to_filters())
+
+    def list_freefloatings_nearby_with_resource_path(
+        self,
+        region_id: str,
+        resource_path: str,
+        request: FreefloatingsNearbyRequest,
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        """Retrieve free-floating vehicles near a specific resource path in a region.
+
+        This service provides access to nearby shared mobility options (such as bikes,
+        scooters, or cars) near a specific resource (stop area, address, etc.).
+
+        Args:
+            region_id: The region ID (coverage identifier).
+            resource_path: The resource path (e.g., 'stop_areas/stop_area:XXX').
+            request: The request object containing query parameters.
+
+        Returns:
+            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"
+        return self._get_freefloatings_nearby(request_url, request.to_filters())
+
+    def list_freefloatings_nearby_by_coordinates(
+        self,
+        region_lon: float,
+        region_lat: float,
+        lon: float,
+        lat: float,
+        request: FreefloatingsNearbyRequest = FreefloatingsNearbyRequest(),
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        """Retrieve 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.
+
+        Args:
+            region_lon: The longitude coordinate for region identification.
+            region_lat: The latitude coordinate for region identification.
+            lon: The longitude coordinate for the search center.
+            lat: The latitude coordinate for the search center.
+            request: The request object containing query parameters.
+
+        Returns:
+            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"
+        return self._get_freefloatings_nearby(request_url, request.to_filters())
+
+    def list_freefloatings_nearby_by_coordinates_only(
+        self,
+        lon: float,
+        lat: float,
+        request: FreefloatingsNearbyRequest = FreefloatingsNearbyRequest(),
+    ) -> Tuple[Sequence[FreeFloating], Pagination]:
+        """Retrieve 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.
+
+        Args:
+            lon: The longitude coordinate.
+            lat: The latitude coordinate.
+            request: The request object containing query parameters.
+
+        Returns:
+            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"
+        return self._get_freefloatings_nearby(request_url, request.to_filters())