python-navitia-client 1.1.0__py3-none-any.whl

navitia_client/client/apis/line_report_apis.py

@@ -0,0 +1,106 @@
+from datetime import datetime
+from typing import Optional, Sequence, Tuple
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.disruption import Disruption
+from navitia_client.entities.line_report import LineReport
+
+
+class LineReportsApiClient(ApiBaseClient):
+    """
+    A client class to interact with the Navitia API for fetching line reports.
+
+    See https://doc.navitia.io/#line-reports
+
+    Methods
+    -------
+    _get_line_reports(url: str, filters: dict) -> Tuple[Sequence[Disruption], Sequence[LineReport]]:
+        Retrieves line reports from the specified URL with the provided filters.
+
+    list_line_reports(region_id: Optional[str] = None, resource_path: Optional[str] = None, since: Optional[datetime] = None, until: Optional[datetime] = None, count: int = 25, depth: int = 1, forbidden_uris: Optional[Sequence[str]] = None, disable_geojson: bool = False) -> Tuple[Sequence[Disruption], Sequence[LineReport]]:
+        Lists line reports based on specified criteria.
+    """
+
+    def _get_line_reports(
+        self, url: str, filters: dict
+    ) -> Tuple[Sequence[Disruption], Sequence[LineReport]]:
+        """
+        Retrieves line reports from the specified URL with the provided filters.
+
+        Parameters
+        ----------
+        url : str
+            The URL to fetch line reports from.
+        filters : dict
+            Filters to apply to the API request.
+
+        Returns
+        -------
+        Tuple[Sequence[Disruption], Sequence[LineReport]]
+            A tuple containing sequences of Disruption and LineReport objects.
+        """
+        results = self.get_navitia_api(url + self._generate_filter_query(filters))
+        line_reports = [
+            LineReport.from_payload(data) for data in results.json()["line_reports"]
+        ]
+        disruptions = [
+            Disruption.from_payload(data) for data in results.json()["disruptions"]
+        ]
+        return disruptions, line_reports
+
+    def list_line_reports(
+        self,
+        region_id: Optional[str] = None,
+        resource_path: Optional[str] = None,
+        since: Optional[datetime] = None,
+        until: Optional[datetime] = None,
+        count: int = 25,
+        depth: int = 1,
+        forbidden_uris: Optional[Sequence[str]] = None,
+        disable_geojson: bool = False,
+    ) -> Tuple[Sequence[Disruption], Sequence[LineReport]]:
+        """
+        Lists line reports based on specified criteria.
+
+        Parameters
+        ----------
+        region_id : Optional[str], optional
+            The ID of the region for which to fetch line reports, by default None.
+        resource_path : Optional[str], optional
+            The resource path for line reports, by default None.
+        since : Optional[datetime], optional
+            Filter line reports since this date and time, by default None.
+        until : Optional[datetime], optional
+            Filter line reports until this date and time, by default None.
+        count : int, optional
+            The number of line reports to retrieve, by default 25.
+        depth : int, optional
+            The depth of the query, by default 1.
+        forbidden_uris : Optional[Sequence[str]], optional
+            List of URIs to forbid, by default None.
+        disable_geojson : bool, optional
+            Whether to disable GeoJSON output, by default False.
+
+        Returns
+        -------
+        Tuple[Sequence[Disruption], Sequence[LineReport]]
+            A tuple containing sequences of Disruption and LineReport objects.
+        """
+        if resource_path:
+            request_url = f"{self.base_navitia_url}/coverage/{region_id}/{resource_path}/line_reports"
+        else:
+            request_url = f"{self.base_navitia_url}/coverage/{region_id}/line_reports"
+
+        filters = {
+            "count": count,
+            "depth": depth,
+            "disable_geojson": disable_geojson,
+            "forbidden_uris[]": forbidden_uris,
+        }
+
+        if since:
+            filters["since"] = since.isoformat()
+
+        if until:
+            filters["until"] = until.isoformat()
+
+        return self._get_line_reports(request_url, filters)

navitia_client/client/apis/place_apis.py

@@ -0,0 +1,74 @@
+from typing import Any, Optional, Sequence, Tuple
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.place import Place
+
+
+class PlacesApiClient(ApiBaseClient):
+    """
+    A client class to interact with the Navitia API for fetching place information.
+
+    See https://doc.navitia.io/#places
+
+    Methods
+    -------
+    _get_pt_objects_from_response(response: Any) -> Sequence[Place]
+        A static method to transform raw API response data into a list of Place objects.
+
+    list_places(
+        region_id: str, query: str,
+        type: Sequence[str] = ["stop_area", "address", "poi", "administrative_region"],
+        disable_geojson: bool = False, depth: int = 1,
+        from_lon_lat: Optional[Tuple[float, float]] = None
+    ) -> Sequence[Place]
+        Retrieves a list of places based on the provided query and region ID from the Navitia API.
+    """
+
+    @staticmethod
+    def _get_pt_objects_from_response(response: Any) -> Sequence[Place]:
+        """
+        Transform raw API response data into a list of Place objects.
+
+        Parameters:
+            response (Any): The raw API response data.
+
+        Returns:
+            Sequence[Place]: A list of Place objects.
+        """
+        entities = []
+        for entity_data in response:
+            entities.append(Place.from_payload(entity_data))
+        return entities
+
+    def list_places(
+        self,
+        region_id: str,
+        query: str,
+        type: Sequence[str] = ["stop_area", "address", "poi", "administrative_region"],
+        disable_geojson: bool = False,
+        depth: int = 1,
+        from_lon_lat: Optional[Tuple[float, float]] = None,
+    ) -> Sequence[Place]:
+        """
+        Retrieves a list of places based on the provided query and region ID from the Navitia API.
+
+        Parameters:
+            region_id (str): The region ID.
+            query (str): The query string to search for places.
+            type (Sequence[str], optional): The types of places to include in the search.
+                Defaults to ["stop_area", "address", "poi", "administrative_region"].
+            disable_geojson (bool, optional): Whether to disable GeoJSON format in the response.
+                Defaults to False.
+            depth (int, optional): The depth of data to retrieve. Defaults to 1.
+            from_lon_lat (Optional[Tuple[float, float]], optional): The longitude and latitude
+                from which to search for places. Defaults to None.
+
+        Returns:
+            Sequence[Place]: A list of Place objects matching the query.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{region_id}/places?q={query}&type={type}&disable_geojson={disable_geojson}&depth={depth}"
+        if from_lon_lat:
+            request_url += f"&filter={from_lon_lat[0]};{from_lon_lat[1]}"
+
+        results = self.get_navitia_api(request_url)
+        raw_results = results.json()["places"]
+        return self._get_pt_objects_from_response(raw_results)

navitia_client/client/apis/places_nearby_apis.py

@@ -0,0 +1,354 @@
+from typing import Any, Optional, Sequence, Tuple
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.pagination import Pagination
+from navitia_client.entities.place import Place
+
+
+class PlacesNearbyApiClient(ApiBaseClient):
+    """
+    A client class to interact with the Navitia API for fetching nearby places information.
+
+    See https://doc.navitia.io/#places_nearby
+
+    Methods
+    -------
+    _get_pt_objects_from_response(response: Any) -> Sequence[Place]
+        A static method to transform raw API response data into a list of Place objects.
+
+    list_objects_by_region_id_and_path(
+        region_id: str, resource_path: str,
+        distance: int = 500, type: Sequence[str] = ["stop_area", "stop_point", "poi"],
+        admin_uri: Optional[Sequence[str]] = None, filter: Optional[str] = None,
+        disable_geojson: bool = False, disable_disruption: bool = False,
+        depth: int = 1, start_page: int = 0, count: int = 25,
+        add_poi_infos: Sequence[str] = ["bss_stands", "car_park"]
+    ) -> Tuple[Sequence[Place], Pagination]
+        Retrieves a list of places nearby based on the region ID and resource path from the Navitia API.
+
+    list_objects_by_region_id_and_coordinates(
+        region_id: str, lon: float, lat: float,
+        distance: int = 500, type: Sequence[str] = ["stop_area", "stop_point", "poi"],
+        admin_uri: Optional[Sequence[str]] = None, filter: Optional[str] = None,
+        disable_geojson: bool = False, disable_disruption: bool = False,
+        depth: int = 1, start_page: int = 0, count: int = 25,
+        add_poi_infos: Sequence[str] = ["bss_stands", "car_park"]
+    ) -> Tuple[Sequence[Place], Pagination]
+        Retrieves a list of places nearby based on the region ID and coordinates from the Navitia API.
+
+    list_objects_by_coordinates(
+        region_lon: float, region_lat: float, lon: float, lat: float,
+        distance: int = 500, type: Sequence[str] = ["stop_area", "stop_point", "poi"],
+        admin_uri: Optional[Sequence[str]] = None, filter: Optional[str] = None,
+        disable_geojson: bool = False, disable_disruption: bool = False,
+        depth: int = 1, start_page: int = 0, count: int = 25,
+        add_poi_infos: Sequence[str] = ["bss_stands", "car_park"]
+    ) -> Tuple[Sequence[Place], Pagination]
+        Retrieves a list of places nearby based on the coordinates from the Navitia API.
+
+    list_objects_by_object_coordinates_only(
+        lon: float, lat: float, distance: int = 500,
+        type: Sequence[str] = ["stop_area", "stop_point", "poi"],
+        admin_uri: Optional[Sequence[str]] = None, filter: Optional[str] = None,
+        disable_geojson: bool = False, disable_disruption: bool = False,
+        depth: int = 1, start_page: int = 0, count: int = 25,
+        add_poi_infos: Sequence[str] = ["bss_stands", "car_park"]
+    ) -> Tuple[Sequence[Place], Pagination]
+        Retrieves a list of places nearby based on the coordinates only from the Navitia API.
+    """
+
+    @staticmethod
+    def _get_pt_objects_from_response(response: Any) -> Sequence[Place]:
+        """
+        Transform raw API response data into a list of Place objects.
+
+        Parameters:
+            response (Any): The raw API response data.
+
+        Returns:
+            Sequence[Place]: A list of Place objects.
+        """
+        entities = []
+        for entity_data in response:
+            entities.append(Place.from_payload(entity_data))
+
+        return entities
+
+    def _get_places_nearby(
+        self, url: str, filters: dict
+    ) -> Tuple[Sequence[Place], Pagination]:
+        """
+        Fetches nearby places based on the provided URL and filters.
+
+        Parameters:
+            url (str): The URL for the API request.
+            filters (dict): Filters to be applied to the API request.
+
+        Returns:
+            Tuple[Sequence[Place], Pagination]: A tuple containing a list of nearby Place objects
+                and pagination information.
+        """
+        results = self.get_navitia_api(url + self._generate_filter_query(filters))
+        raw_results = results.json()["places_nearby"]
+        pagination = Pagination.from_payload(results.json()["pagination"])
+        return self._get_pt_objects_from_response(raw_results), pagination
+
+    def list_objects_by_region_id_and_path(
+        self,
+        region_id: str,
+        resource_path: str,
+        distance: int = 500,
+        type: Sequence[str] = ["stop_area", "stop_point", "poi"],
+        admin_uri: Optional[Sequence[str]] = None,
+        filter: Optional[str] = None,
+        disable_geojson: bool = False,
+        disable_disruption: bool = False,
+        depth: int = 1,
+        start_page: int = 0,
+        count: int = 25,
+        add_poi_infos: Sequence[str] = ["bss_stands", "car_park"],
+    ) -> Tuple[Sequence[Place], Pagination]:
+        """
+        Retrieves a list of places nearby based on the region ID and resource path from the Navitia API.
+
+        Parameters:
+            region_id (str): The region ID.
+            resource_path (str): The resource path.
+            distance (int, optional): The distance for nearby search. Defaults to 500.
+            type (Sequence[str], optional): The types of places to include in the search.
+                Defaults to ["stop_area", "stop_point", "poi"].
+            admin_uri (Optional[Sequence[str]], optional): The administrative URIs to filter by.
+                Defaults to None.
+            filter (Optional[str], optional): Additional filtering criteria. Defaults to None.
+            disable_geojson (bool, optional): Whether to disable GeoJSON format in the response.
+                Defaults to False.
+            disable_disruption (bool, optional): Whether to disable disruption information.
+                Defaults to False.
+            depth (int, optional): The depth of data to retrieve. Defaults to 1.
+            start_page (int, optional): The starting page for pagination. Defaults to 0.
+            count (int, optional): The number of items per page. Defaults to 25.
+            add_poi_infos (Sequence[str], optional): Additional POI information to include.
+                Defaults to ["bss_stands", "car_park"].
+
+        Returns:
+            Tuple[Sequence[Place], Pagination]: A tuple containing a list of nearby Place objects
+                and pagination information.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{region_id}/{resource_path}/places_nearby"
+
+        filters = {
+            "start_page": start_page,
+            "count": count,
+            "depth": depth,
+            "type[]": type,
+            "distance": distance,
+            "disable_geojson": disable_geojson,
+            "disable_disruption": disable_disruption,
+            "add_poi_infos[]": add_poi_infos,
+        }
+
+        if admin_uri:
+            filters["admin_uris[]"] = admin_uri
+
+        if filter:
+            filters["filter"] = filter
+
+        return self._get_places_nearby(request_url, filters)
+
+    def list_objects_by_region_id_and_coordinates(
+        self,
+        region_id: str,
+        lon: float,
+        lat: float,
+        distance: int = 500,
+        type: Sequence[str] = ["stop_area", "stop_point", "poi"],
+        admin_uri: Optional[Sequence[str]] = None,
+        filter: Optional[str] = None,
+        disable_geojson: bool = False,
+        disable_disruption: bool = False,
+        depth: int = 1,
+        start_page: int = 0,
+        count: int = 25,
+        add_poi_infos: Sequence[str] = ["bss_stands", "car_park"],
+    ) -> Tuple[Sequence[Place], Pagination]:
+        """
+        Retrieves a list of places nearby based on the region ID and coordinates from the Navitia API.
+
+        Parameters:
+            region_id (str): The region ID.
+            lon (float): The longitude coordinate.
+            lat (float): The latitude coordinate.
+            distance (int, optional): The distance for nearby search. Defaults to 500.
+            type (Sequence[str], optional): The types of places to include in the search.
+                Defaults to ["stop_area", "stop_point", "poi"].
+            admin_uri (Optional[Sequence[str]], optional): The administrative URIs to filter by.
+                Defaults to None.
+            filter (Optional[str], optional): Additional filtering criteria. Defaults to None.
+            disable_geojson (bool, optional): Whether to disable GeoJSON format in the response.
+                Defaults to False.
+            disable_disruption (bool, optional): Whether to disable disruption information.
+                Defaults to False.
+            depth (int, optional): The depth of data to retrieve. Defaults to 1.
+            start_page (int, optional): The starting page for pagination. Defaults to 0.
+            count (int, optional): The number of items per page. Defaults to 25.
+            add_poi_infos (Sequence[str], optional): Additional POI information to include.
+                Defaults to ["bss_stands", "car_park"].
+
+        Returns:
+            Tuple[Sequence[Place], Pagination]: A tuple containing a list of nearby Place objects
+                and pagination information.
+        """
+        request_url = (
+            f"{self.base_navitia_url}/coverage/{region_id}/{lon};{lat}/places_nearby"
+        )
+
+        filters = {
+            "start_page": start_page,
+            "count": count,
+            "depth": depth,
+            "type[]": type,
+            "distance": distance,
+            "disable_geojson": disable_geojson,
+            "disable_disruption": disable_disruption,
+            "add_poi_infos[]": add_poi_infos,
+        }
+
+        if admin_uri:
+            filters["admin_uris[]"] = admin_uri
+
+        if filter:
+            filters["filter"] = filter
+
+        return self._get_places_nearby(request_url, filters)
+
+    def list_objects_by_coordinates(
+        self,
+        region_lon: float,
+        region_lat: float,
+        lon: float,
+        lat: float,
+        distance: int = 500,
+        type: Sequence[str] = ["stop_area", "stop_point", "poi"],
+        admin_uri: Optional[Sequence[str]] = None,
+        filter: Optional[str] = None,
+        disable_geojson: bool = False,
+        disable_disruption: bool = False,
+        depth: int = 1,
+        start_page: int = 0,
+        count: int = 25,
+        add_poi_infos: Sequence[str] = ["bss_stands", "car_park"],
+    ) -> Tuple[Sequence[Place], Pagination]:
+        """
+        Retrieves a list of places nearby based on the provided coordinates from the Navitia API.
+
+        Parameters:
+            region_lon (float): The longitude coordinate of the region.
+            region_lat (float): The latitude coordinate of the region.
+            lon (float): The longitude coordinate.
+            lat (float): The latitude coordinate.
+            distance (int, optional): The distance for nearby search. Defaults to 500.
+            type (Sequence[str], optional): The types of places to include in the search.
+                Defaults to ["stop_area", "stop_point", "poi"].
+            admin_uri (Optional[Sequence[str]], optional): The administrative URIs to filter by.
+                Defaults to None.
+            filter (Optional[str], optional): Additional filtering criteria. Defaults to None.
+            disable_geojson (bool, optional): Whether to disable GeoJSON format in the response.
+                Defaults to False.
+            disable_disruption (bool, optional): Whether to disable disruption information.
+                Defaults to False.
+            depth (int, optional): The depth of data to retrieve. Defaults to 1.
+            start_page (int, optional): The starting page for pagination. Defaults to 0.
+            count (int, optional): The number of items per page. Defaults to 25.
+            add_poi_infos (Sequence[str], optional): Additional POI information to include.
+                Defaults to ["bss_stands", "car_park"].
+
+        Returns:
+            Tuple[Sequence[Place], Pagination]: A tuple containing a list of nearby Place objects
+                and pagination information.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{region_lon};{region_lat}/coords/{lon};{lat}/places_nearby"
+
+        filters = {
+            "start_page": start_page,
+            "count": count,
+            "depth": depth,
+            "type[]": type,
+            "distance": distance,
+            "disable_geojson": disable_geojson,
+            "disable_disruption": disable_disruption,
+            "add_poi_infos[]": add_poi_infos,
+        }
+
+        if admin_uri:
+            filters["admin_uris[]"] = admin_uri
+
+        if filter:
+            filters["filter"] = filter
+
+        return self._get_places_nearby(request_url, filters)
+
+    def list_objects_by_object_coordinates_only(
+        self,
+        lon: float,
+        lat: float,
+        distance: int = 500,
+        type: Sequence[str] = ["stop_area", "stop_point", "poi"],
+        admin_uri: Optional[Sequence[str]] = None,
+        filter: Optional[str] = None,
+        disable_geojson: bool = False,
+        disable_disruption: bool = False,
+        depth: int = 1,
+        start_page: int = 0,
+        count: int = 25,
+        add_poi_infos: Sequence[str] = ["bss_stands", "car_park"],
+    ) -> Tuple[Sequence[Place], Pagination]:
+        """
+        Retrieves a list of places nearby based on the provided coordinates from the Navitia API.
+
+        Parameters:
+            lon (float): The longitude coordinate.
+            lat (float): The latitude coordinate.
+            distance (int, optional): The distance for nearby search. Defaults to 500.
+            type (Sequence[str], optional): The types of places to include in the search.
+                Defaults to ["stop_area", "stop_point", "poi"].
+            admin_uri (Optional[Sequence[str]], optional): The administrative URIs to filter by.
+                Defaults to None.
+            filter (Optional[str], optional): Additional filtering criteria. Defaults to None.
+            disable_geojson (bool, optional): Whether to disable GeoJSON format in the response.
+                Defaults to False.
+            disable_disruption (bool, optional): Whether to disable disruption information.
+                Defaults to False.
+            depth (int, optional): The depth of data to retrieve. Defaults to 1.
+            start_page (int, optional): The starting page for pagination. Defaults to 0.
+            count (int, optional): The number of items per page. Defaults to 25.
+            add_poi_infos (Sequence[str], optional): Additional POI information to include.
+                Defaults to ["bss_stands", "car_park"].
+
+        Returns:
+            Tuple[Sequence[Place], Pagination]: A tuple containing a list of nearby Place objects
+                and pagination information.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{lon};{lat}/places_nearby"
+
+        if not request_url:
+            raise ValueError(
+                "Region id, region coordinates or coordinates must be provided."
+            )
+
+        filters = {
+            "start_page": start_page,
+            "count": count,
+            "depth": depth,
+            "type[]": type,
+            "distance": distance,
+            "disable_geojson": disable_geojson,
+            "disable_disruption": disable_disruption,
+            "add_poi_infos[]": add_poi_infos,
+        }
+
+        if admin_uri:
+            filters["admin_uris[]"] = admin_uri
+
+        if filter:
+            filters["filter"] = filter
+
+        return self._get_places_nearby(request_url, filters)

navitia_client/client/apis/public_transport_objects_apis.py

@@ -0,0 +1,88 @@
+from typing import Any, Optional, Sequence
+from navitia_client.client.apis.api_base_client import ApiBaseClient
+from navitia_client.entities.pt_object import PtObject
+
+
+class PublicTransportObjectsApiClient(ApiBaseClient):
+    """
+    A client class to interact with the Navitia API for fetching public transport objects.
+
+    See https://doc.navitia.io/#pt-objects
+
+    Methods
+    -------
+    _get_pt_objects_from_response(response: Any) -> Sequence[PtObject]:
+        A static method to transform raw API response data into a list of PtObject objects.
+
+    list_public_transport_objects(
+        region_id: str,
+        query: str,
+        type: Sequence[str] = [
+            "network",
+            "commercial_mode",
+            "line",
+            "route",
+            "stop_area",
+        ],
+        disable_disruption: bool = False,
+        depth: int = 1,
+        post_query_filter: Optional[str] = None,
+    ) -> Sequence[PtObject]:
+        Retrieves a list of public transport objects for a specified region from the Navitia API.
+    """
+
+    @staticmethod
+    def _get_pt_objects_from_response(response: Any) -> Sequence[PtObject]:
+        """
+        Static method to transform raw API response data into a list of PtObject objects.
+
+        Parameters:
+            response (Any): The raw API response data.
+
+        Returns:
+            Sequence[PtObject]: A sequence of PtObject objects.
+        """
+        pt_objects = []
+        for pt_objects_data in response:
+            pt_objects.append(PtObject.from_payload(pt_objects_data))
+
+        return pt_objects
+
+    def list_public_transport_objects(
+        self,
+        region_id: str,
+        query: str,
+        type: Sequence[str] = [
+            "network",
+            "commercial_mode",
+            "line",
+            "route",
+            "stop_area",
+        ],
+        disable_disruption: bool = False,
+        depth: int = 1,
+        post_query_filter: Optional[str] = None,
+    ) -> Sequence[PtObject]:
+        """
+        Retrieves a list of public transport objects for a specified region from the Navitia API.
+
+        Parameters:
+            region_id (str): The region ID.
+            query (str): The search query.
+            type (Sequence[str], optional): The types of public transport objects to include
+                in the search. Defaults to ["network", "commercial_mode", "line", "route", "stop_area"].
+            disable_disruption (bool, optional): Whether to disable disruption information in the response.
+                Defaults to False.
+            depth (int, optional): The depth of data to retrieve. Defaults to 1.
+            post_query_filter (Optional[str], optional): Additional filtering criteria. Defaults to None.
+
+        Returns:
+            Sequence[PtObject]: A sequence of PtObject objects.
+        """
+        request_url = f"{self.base_navitia_url}/coverage/{region_id}/pt_objects?q={query}&type={type}&disable_disruption={disable_disruption}&depth={depth}"
+        if post_query_filter:
+            request_url += f"&filter={post_query_filter}"
+
+        results = self.get_navitia_api(request_url)
+        raw_results = results.json()["pt_objects"]
+        return self._get_pt_objects_from_response(raw_results)

navitia_client/client/apis/public_transportation_apis/__init__.py

@@ -0,0 +1,10 @@
+from .commercial_mode_apis import CommercialModeApiClient  # noqa: F401
+from .company_apis import CompanyApiClient  # noqa: F401
+from .disruption_apis import DisruptionApiClient  # noqa: F401
+from .line_apis import LineApiClient  # noqa: F401
+from .network_apis import NetworkApiClient  # noqa: F401
+from .physical_mode_apis import PhysicalModeApiClient  # noqa: F401
+from .route_apis import RouteApiClient  # noqa: F401
+from .stop_area_apis import StopAreaApiClient  # noqa: F401
+from .stop_point_apis import StopPointApiClient  # noqa: F401
+from .vehicle_journey_apis import VehicleJourneyApiClient  # noqa: F401