feat: add gbfs bounding box (#1393)

Author: davidgamez

api/src/feeds/impl/models/gbfs_feed_impl.py

@@ -1,3 +1,4 @@
+from feeds.impl.models.bounding_box_impl import BoundingBoxImpl
 from feeds.impl.models.feed_impl import FeedImpl
 from feeds.impl.models.gbfs_version_impl import GbfsVersionImpl
 from shared.database_gen.sqlacodegen_models import Gbfsfeed as GbfsFeedOrm
@@ -29,4 +30,6 @@ def from_orm(cls, feed: GbfsFeedOrm | None) -> GbfsFeed | None:
             if feed.gbfsversions
             else []
         )
+        gbfs_feed.bounding_box = BoundingBoxImpl.from_orm(feed.bounding_box)
+        gbfs_feed.bounding_box_generated_at = feed.bounding_box_generated_at
         return gbfs_feed

api/tests/unittest/models/test_gbfs_feed_impl.py

@@ -0,0 +1,106 @@
+import unittest
+from datetime import datetime
+
+from geoalchemy2 import WKTElement
+
+from feeds_gen.models.source_info import SourceInfo
+from shared.database_gen.sqlacodegen_models import Gbfsfeed, Location, Gbfsversion
+from feeds.impl.models.gbfs_feed_impl import GbfsFeedImpl
+from feeds.impl.models.location_impl import LocationImpl
+from feeds.impl.models.gbfs_version_impl import GbfsVersionImpl
+from feeds.impl.models.bounding_box_impl import BoundingBoxImpl
+
+POLYGON = "POLYGON ((3.0 1.0, 4.0 1.0, 4.0 2.0, 3.0 2.0, 3.0 1.0))"
+
+
+class TestGbfsFeedImpl(unittest.TestCase):
+    def setUp(self):
+        self.location_orm = Location(
+            id="loc1",
+            country_code="US",
+            country="United States",
+            subdivision_name="California",
+            municipality="San Francisco",
+        )
+        self.version_orm = Gbfsversion(
+            id="ver1",
+            version="2.2",
+            url="https://example.com/gbfs.json",
+        )
+        self.bounding_box_orm = WKTElement(POLYGON, srid=4326)
+        self.feed_orm = Gbfsfeed(
+            id="feed1",
+            stable_id="feed_stable_1",
+            created_at=datetime(2024, 1, 1, 10, 0, 0),
+            data_type="gbfs",
+            system_id="sys1",
+            operator_url="https://provider.com",
+            locations=[self.location_orm],
+            gbfsversions=[self.version_orm],
+            bounding_box=self.bounding_box_orm,
+            bounding_box_generated_at=datetime(2024, 1, 1, 12, 0, 0),
+            authentication_type=0,
+            authentication_info_url="https://auth.info",
+            api_key_parameter_name="api_key",
+            license_url="https://license.info",
+        )
+
+    def test_from_orm_all_fields(self):
+        expected = GbfsFeedImpl(
+            id="feed_stable_1",
+            system_id="sys1",
+            data_type="gbfs",
+            created_at=datetime(2024, 1, 1, 10, 0, 0),
+            external_ids=[],
+            redirects=[],
+            provider_url="https://provider.com",
+            locations=[LocationImpl.from_orm(self.location_orm)],
+            versions=[GbfsVersionImpl.from_orm(self.version_orm)],
+            bounding_box=BoundingBoxImpl.from_orm(self.bounding_box_orm),
+            bounding_box_generated_at=datetime(2024, 1, 1, 12, 0, 0),
+            source_info=SourceInfo(
+                producer_url=None,
+                authentication_type=0,
+                authentication_info_url="https://auth.info",
+                api_key_parameter_name="api_key",
+                license_url="https://license.info",
+            ),
+        )
+        result = GbfsFeedImpl.from_orm(self.feed_orm)
+        self.assertEqual(result, expected)
+
+    def test_from_orm_empty_fields(self):
+        feed_orm = Gbfsfeed(
+            id="feed2",
+            stable_id="feed_stable_2",
+            system_id=None,
+            operator_url=None,
+            locations=[],
+            gbfsversions=[],
+            bounding_box=None,
+            bounding_box_generated_at=None,
+        )
+        expected = GbfsFeedImpl(
+            id="feed_stable_2",
+            system_id=None,
+            provider_url=None,
+            external_ids=[],
+            redirects=[],
+            locations=[],
+            versions=[],
+            bounding_box=None,
+            bounding_box_generated_at=None,
+            source_info=SourceInfo(
+                producer_url=None,
+                authentication_type=None,
+                authentication_info_url=None,
+                api_key_parameter_name=None,
+                license_url=None,
+            ),
+        )
+        result = GbfsFeedImpl.from_orm(feed_orm)
+        self.assertEqual(result, expected)
+
+    def test_from_orm_none(self):
+        result = GbfsFeedImpl.from_orm(None)
+        self.assertIsNone(result)

docs/DatabaseCatalogAPI.yaml

@@ -512,6 +512,13 @@ components:
               type: array
               items:
                   $ref: "#/components/schemas/GbfsVersion"
+            bounding_box:
+              $ref: "#/components/schemas/BoundingBox"
+            bounding_box_generated_at:
+              description: The date and time the bounding box was generated, in ISO 8601 date-time format.
+              type: string
+              example: 2023-07-10T22:06:00Z
+              format: date-time             
 
     GbfsVersion:
       type: object

functions-python/reverse_geolocation/src/reverse_geolocation_processor.py

@@ -219,7 +219,10 @@ def get_storage_client():
 
 @track_metrics(metrics=("time", "memory", "cpu"))
 def update_dataset_bounding_box(
-    gtfs_dataset: Gtfsdataset, stops_df: pd.DataFrame, db_session: Session
+    feed: Gtfsfeed | Gbfsfeed,
+    gtfs_dataset: Gtfsdataset,
+    stops_df: pd.DataFrame,
+    db_session: Session,
 ) -> shapely.Polygon:
     """
     Update the bounding box of the dataset using the stops DataFrame.
@@ -237,16 +240,17 @@ def update_dataset_bounding_box(
         f")",
         srid=4326,
     )
-    if not gtfs_dataset:
-        return to_shape(bounding_box)
-    gtfs_feed = db_session.get(Gtfsfeed, gtfs_dataset.feed_id)
-    if not gtfs_feed:
-        raise ValueError(
-            f"GTFS feed for dataset {gtfs_dataset.stable_id} does not exist in the database."
-        )
-    gtfs_feed.bounding_box = bounding_box
-    gtfs_feed.bounding_box_dataset = gtfs_dataset
-    gtfs_dataset.bounding_box = bounding_box
+    if feed.data_type == "gtfs":
+        if not gtfs_dataset:
+            return to_shape(bounding_box)
+        feed.bounding_box = bounding_box
+        feed.bounding_box_dataset = gtfs_dataset
+        gtfs_dataset.bounding_box = bounding_box
+    elif feed.data_type == "gbfs":
+        feed.bounding_box = bounding_box
+        feed.bounding_box_generated_at = get_db_timestamp(db_session)
+    else:
+        raise ValueError("The data type must be either 'gtfs' or 'gbfs'.")
 
     return to_shape(bounding_box)
 
@@ -349,7 +353,12 @@ def reverse_geolocation_process(
             gtfs_dataset = load_dataset(dataset_id, db_session)
         feed = load_feed(stable_id, data_type, logger, db_session)
 
-        bounding_box = update_dataset_bounding_box(gtfs_dataset, stops_df, db_session)
+        bounding_box = update_dataset_bounding_box(
+            feed=feed,
+            gtfs_dataset=gtfs_dataset,
+            stops_df=stops_df,
+            db_session=db_session,
+        )
 
         location_groups = reverse_geolocation(
             strategy=strategy,

functions-python/reverse_geolocation/tests/test_reverse_geolocation_processor.py

@@ -368,6 +368,7 @@ def test_update_dataset_bounding_box_success(self, db_session):
         feed_id = faker.uuid4(cast_to=str)
         feed = Gtfsfeed(
             id=feed_id,
+            data_type="gtfs",
             stable_id=faker.uuid4(cast_to=str),
         )
         dataset_id = faker.uuid4(cast_to=str)
@@ -391,7 +392,7 @@ def test_update_dataset_bounding_box_success(self, db_session):
 
         # Call the function
         bounding_box = update_dataset_bounding_box(
-            dataset, stops_df, db_session=db_session
+            feed, dataset, stops_df, db_session=db_session
         )
 
         # Expected bounding box: POLYGON((30 10, 40 10, 40 20, 30 20, 30 10))
@@ -425,7 +426,7 @@ def test_update_dataset_bounding_box_exception(self, db_session):
 
         with self.assertRaises(Exception):
             update_dataset_bounding_box(
-                faker.uuid4(cast_to=str), stops_df, db_session=db_session
+                MagicMock(), faker.uuid4(cast_to=str), stops_df, db_session=db_session
             )
 
     @patch("reverse_geolocation_processor.parse_request_parameters")

liquibase/changelog.xml

@@ -70,4 +70,5 @@
     <include file="changes/feat_pt_152.sql" relativeToChangelogFile="true"/>
     <include file="changes/feat_fix_geolocation_circular_dep.sql" relativeToChangelogFile="true"/>
     <include file="changes/feat_1325.sql" relativeToChangelogFile="true"/>
+    <include file="changes/feat_pt_156.sql" relativeToChangelogFile="true"/>
 </databaseChangeLog>

liquibase/changes/feat_pt_156.sql

@@ -0,0 +1,6 @@
+-- Add the new columns to gbfsfeed (if not already added)
+-- No foreign keys to versions as versions are not kept between updates
+ALTER TABLE gbfsfeed
+  ADD COLUMN IF NOT EXISTS bounding_box geometry(Polygon, 4326);
+ALTER TABLE gbfsfeed
+  ADD COLUMN IF NOT EXISTS bounding_box_generated_at TIMESTAMP DEFAULT NULL;

web-app/public/locales/en/feeds.json

@@ -76,7 +76,7 @@
   "gtfsVisualizationTooltip": "View the routes and stops of the feed",
   "detailedCoveredAreaView": "Detailed",
   "detailedCoveredAreaViewTooltip": "View the detailed covered area of the feed",
-  "unableToGenerateBoundingBox": "Unable to generate bounding box from the feed's stops.txt file.",
+  "unableToGenerateBoundingBox": "Unable to generate bounding box from the feed",
   "unableToGetGbfsMap": "Error fetching GBFS Map",
   "areYouOfficialProducer": "Are you the official producer or transit agency responsible for this data ?",
   "isOfficialSource": "Is this an official data source?",