feat: added GBFS endpoints (#1103)

Author: cka-y

api/.openapi-generator/FILES

@@ -1,5 +1,7 @@
 src/feeds/impl/__init__.py
 src/feeds_gen/apis/__init__.py
+src/feeds_gen/apis/beta_api.py
+src/feeds_gen/apis/beta_api_base.py
 src/feeds_gen/apis/datasets_api.py
 src/feeds_gen/apis/datasets_api_base.py
 src/feeds_gen/apis/feeds_api.py
@@ -15,6 +17,11 @@ src/feeds_gen/models/basic_feed.py
 src/feeds_gen/models/bounding_box.py
 src/feeds_gen/models/external_id.py
 src/feeds_gen/models/extra_models.py
+src/feeds_gen/models/feed.py
+src/feeds_gen/models/gbfs_endpoint.py
+src/feeds_gen/models/gbfs_feed.py
+src/feeds_gen/models/gbfs_validation_report.py
+src/feeds_gen/models/gbfs_version.py
 src/feeds_gen/models/gtfs_dataset.py
 src/feeds_gen/models/gtfs_feed.py
 src/feeds_gen/models/gtfs_rt_feed.py

api/src/feeds/impl/feeds_api_impl.py

@@ -6,15 +6,39 @@
 from sqlalchemy.orm import joinedload, Session
 from sqlalchemy.orm.query import Query
 
+from feeds.impl.datasets_api_impl import DatasetsApiImpl
+from feeds.impl.error_handling import raise_http_error, raise_http_validation_error, convert_exception
+from feeds.impl.models.entity_type_enum import EntityType
+from feeds.impl.models.feed_impl import FeedImpl
+from feeds.impl.models.gbfs_feed_impl import GbfsFeedImpl
+from feeds.impl.models.gtfs_feed_impl import GtfsFeedImpl
+from feeds.impl.models.gtfs_rt_feed_impl import GtfsRTFeedImpl
+from feeds_gen.apis.feeds_api_base import BaseFeedsApi
+from feeds_gen.models.feed import Feed
+from feeds_gen.models.gbfs_feed import GbfsFeed
+from feeds_gen.models.gtfs_dataset import GtfsDataset
+from feeds_gen.models.gtfs_feed import GtfsFeed
+from feeds_gen.models.gtfs_rt_feed import GtfsRTFeed
+from middleware.request_context import is_user_email_restricted
 from shared.common.db_utils import (
     get_gtfs_feeds_query,
     get_gtfs_rt_feeds_query,
     get_joinedload_options,
     add_official_filter,
+    get_gbfs_feeds_query,
 )
+from shared.common.error_handling import (
+    invalid_date_message,
+    feed_not_found,
+    gtfs_feed_not_found,
+    gtfs_rt_feed_not_found,
+    InternalHTTPException,
+    gbfs_feed_not_found,
+)
+from shared.common.logging_utils import Logger
 from shared.database.database import Database, with_db_session
 from shared.database_gen.sqlacodegen_models import (
-    Feed,
+    Feed as FeedOrm,
     Gtfsdataset,
     Gtfsfeed,
     Gtfsrealtimefeed,
@@ -25,29 +49,9 @@
 from shared.feed_filters.gtfs_dataset_filter import GtfsDatasetFilter
 from shared.feed_filters.gtfs_feed_filter import LocationFilter
 from shared.feed_filters.gtfs_rt_feed_filter import GtfsRtFeedFilter, EntityTypeFilter
-from feeds.impl.datasets_api_impl import DatasetsApiImpl
-from shared.common.error_handling import (
-    invalid_date_message,
-    feed_not_found,
-    gtfs_feed_not_found,
-    gtfs_rt_feed_not_found,
-    InternalHTTPException,
-)
-from feeds.impl.models.basic_feed_impl import BasicFeedImpl
-from feeds.impl.models.entity_type_enum import EntityType
-from feeds.impl.models.gtfs_feed_impl import GtfsFeedImpl
-from feeds.impl.models.gtfs_rt_feed_impl import GtfsRTFeedImpl
-from feeds_gen.apis.feeds_api_base import BaseFeedsApi
-from feeds_gen.models.basic_feed import BasicFeed
-from feeds_gen.models.gtfs_dataset import GtfsDataset
-from feeds_gen.models.gtfs_feed import GtfsFeed
-from feeds_gen.models.gtfs_rt_feed import GtfsRTFeed
-from feeds.impl.error_handling import raise_http_error, raise_http_validation_error, convert_exception
-from middleware.request_context import is_user_email_restricted
 from utils.date_utils import valid_iso_date
-from shared.common.logging_utils import Logger
 
-T = TypeVar("T", bound="BasicFeed")
+T = TypeVar("T", bound="Feed")
 
 
 class FeedsApiImpl(BaseFeedsApi):
@@ -57,31 +61,30 @@ class FeedsApiImpl(BaseFeedsApi):
     If a method is left blank the associated endpoint will return a 500 HTTP response.
     """
 
-    APIFeedType = Union[BasicFeed, GtfsFeed, GtfsRTFeed]
+    APIFeedType = Union[FeedOrm, GtfsFeed, GtfsRTFeed]
 
     def __init__(self) -> None:
         self.logger = Logger("FeedsApiImpl").get_logger()
 
     @with_db_session
-    def get_feed(self, id: str, db_session: Session) -> BasicFeed:
+    def get_feed(self, id: str, db_session: Session) -> Feed:
         """Get the specified feed from the Mobility Database."""
         is_email_restricted = is_user_email_restricted()
         self.logger.debug(f"User email is restricted: {is_email_restricted}")
 
         feed = (
             FeedFilter(stable_id=id, provider__ilike=None, producer_url__ilike=None, status=None)
-            .filter(Database().get_query_model(db_session, Feed))
-            .filter(Feed.data_type != "gbfs")  # Filter out GBFS feeds
+            .filter(Database().get_query_model(db_session, FeedOrm))
             .filter(
                 or_(
-                    Feed.operational_status == "published",
+                    FeedOrm.operational_status == "published",
                     not is_email_restricted,  # Allow all feeds to be returned if the user is not restricted
                 )
             )
             .first()
         )
         if feed:
-            return BasicFeedImpl.from_orm(feed)
+            return FeedImpl.from_orm(feed)
         else:
             raise_http_error(404, feed_not_found.format(id))
 
@@ -95,32 +98,31 @@ def get_feeds(
         producer_url: str,
         is_official: bool,
         db_session: Session,
-    ) -> List[BasicFeed]:
+    ) -> List[Feed]:
         """Get some (or all) feeds from the Mobility Database."""
         is_email_restricted = is_user_email_restricted()
         self.logger.debug(f"User email is restricted: {is_email_restricted}")
         feed_filter = FeedFilter(
             status=status, provider__ilike=provider, producer_url__ilike=producer_url, stable_id=None
         )
-        feed_query = feed_filter.filter(Database().get_query_model(db_session, Feed))
+        feed_query = feed_filter.filter(Database().get_query_model(db_session, FeedOrm))
         feed_query = add_official_filter(feed_query, is_official)
-        feed_query = feed_query.filter(Feed.data_type != "gbfs")  # Filter out GBFS feeds
         feed_query = feed_query.filter(
             or_(
-                Feed.operational_status == "published",
+                FeedOrm.operational_status == "published",
                 not is_email_restricted,  # Allow all feeds to be returned if the user is not restricted
             )
         )
         # Results are sorted by provider
-        feed_query = feed_query.order_by(Feed.provider, Feed.stable_id)
+        feed_query = feed_query.order_by(FeedOrm.provider, FeedOrm.stable_id)
         feed_query = feed_query.options(*get_joinedload_options())
         if limit is not None:
             feed_query = feed_query.limit(limit)
         if offset is not None:
             feed_query = feed_query.offset(offset)
 
         results = feed_query.all()
-        return [BasicFeedImpl.from_orm(feed) for feed in results]
+        return [FeedImpl.from_orm(feed) for feed in results]
 
     @with_db_session
     def get_gtfs_feed(self, id: str, db_session: Session) -> GtfsFeed:
@@ -163,7 +165,7 @@ def get_gtfs_feed_datasets(
         feed = self._get_gtfs_feed(gtfs_feed_id, db_session, include_options_for_joinedload=False)
 
         if not feed:
-            raise_http_error(404, f"Feed with id {gtfs_feed_id} not found")
+            raise_http_error(404, f"FeedOrm with id {gtfs_feed_id} not found")
 
         # Replace Z with +00:00 to make the datetime object timezone aware
         # Due to https://github.com/python/cpython/issues/80010, once migrate to Python 3.11, we can use fromisoformat
@@ -174,7 +176,7 @@ def get_gtfs_feed_datasets(
             downloaded_at__gte=(
                 datetime.fromisoformat(downloaded_after.replace("Z", "+00:00")) if downloaded_after else None
             ),
-        ).filter(DatasetsApiImpl.create_dataset_query().filter(Feed.stable_id == gtfs_feed_id))
+        ).filter(DatasetsApiImpl.create_dataset_query().filter(FeedOrm.stable_id == gtfs_feed_id))
 
         if latest:
             query = query.filter(Gtfsdataset.latest)
@@ -352,3 +354,47 @@ def get_gtfs_feed_gtfs_rt_feeds(self, id: str, db_session: Session) -> List[Gtfs
             return [GtfsRTFeedImpl.from_orm(gtfs_rt_feed) for gtfs_rt_feed in feed.gtfs_rt_feeds]
         else:
             raise_http_error(404, gtfs_feed_not_found.format(id))
+
+    @with_db_session
+    def get_gbfs_feed(
+        self,
+        id: str,
+        db_session: Session,
+    ) -> GbfsFeed:
+        """Get the specified GBFS feed from the Mobility Database."""
+        result = get_gbfs_feeds_query(db_session, stable_id=id).one_or_none()
+        if result:
+            return GbfsFeedImpl.from_orm(result)
+        else:
+            raise_http_error(404, gbfs_feed_not_found.format(id))
+
+    @with_db_session
+    def get_gbfs_feeds(
+        self,
+        limit: int,
+        offset: int,
+        provider: str,
+        producer_url: str,
+        country_code: str,
+        subdivision_name: str,
+        municipality: str,
+        system_id: str,
+        version: str,
+        db_session: Session,
+    ) -> List[GbfsFeed]:
+        query = get_gbfs_feeds_query(
+            db_session=db_session,
+            provider=provider,
+            producer_url=producer_url,
+            country_code=country_code,
+            subdivision_name=subdivision_name,
+            municipality=municipality,
+            system_id=system_id,
+            version=version,
+        )
+        if limit:
+            query = query.limit(limit)
+        if offset:
+            query = query.offset(offset)
+        results = query.all()
+        return [GbfsFeedImpl.from_orm(feed) for feed in results]

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

@@ -23,16 +23,11 @@ def from_orm(cls, feed: Feed | None) -> BasicFeed | None:
         return cls(
             id=feed.stable_id,
             data_type=feed.data_type,
-            status=feed.status,
-            official=feed.official,
-            official_updated_at=feed.official_updated_at,
             created_at=feed.created_at,
             external_ids=sorted(
                 [ExternalIdImpl.from_orm(item) for item in feed.externalids], key=lambda x: x.external_id
             ),
             provider=feed.provider,
-            feed_name=feed.feed_name,
-            note=feed.note,
             feed_contact_email=feed.feed_contact_email,
             source_info=SourceInfo(
                 producer_url=feed.producer_url,

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

@@ -0,0 +1,27 @@
+from feeds.impl.models.basic_feed_impl import BaseFeedImpl
+from feeds_gen.models.feed import Feed
+from shared.database_gen.sqlacodegen_models import Feed as FeedOrm
+
+
+class FeedImpl(BaseFeedImpl, Feed):
+    """Base implementation of the feeds models.
+    This class converts a SQLAlchemy row DB object with common feed fields to a Pydantic model.
+    """
+
+    class Config:
+        """Pydantic configuration.
+        Enabling `from_attributes` method to create a model instance from a SQLAlchemy row object."""
+
+        from_attributes = True
+
+    @classmethod
+    def from_orm(cls, feed_orm: FeedOrm | None) -> Feed | None:
+        feed: Feed = super().from_orm(feed_orm)
+        if not feed:
+            return None
+        feed.status = feed_orm.status
+        feed.official = feed_orm.official
+        feed.official_updated_at = feed_orm.official_updated_at
+        feed.feed_name = feed_orm.feed_name
+        feed.note = feed_orm.note
+        return feed

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

@@ -0,0 +1,20 @@
+from feeds_gen.models.gbfs_endpoint import GbfsEndpoint
+from shared.database_gen.sqlacodegen_models import Gbfsendpoint as GbfsEndpointOrm
+
+
+class GbfsEndpointImpl(GbfsEndpoint):
+    """Implementation of the `GtfsFeed` model.
+    This class converts a SQLAlchemy row DB object to a Pydantic model.
+    """
+
+    class Config:
+        """Pydantic configuration.
+        Enabling `from_attributes` method to create a model instance from a SQLAlchemy row object."""
+
+        from_attributes = True
+
+    @classmethod
+    def from_orm(cls, endpoint: GbfsEndpointOrm | None) -> GbfsEndpoint | None:
+        if not endpoint:
+            return None
+        return cls(name=endpoint.name, url=endpoint.url, language=endpoint.language, is_feature=endpoint.is_feature)

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

@@ -0,0 +1,32 @@
+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
+from feeds.impl.models.location_impl import LocationImpl
+from feeds_gen.models.gbfs_feed import GbfsFeed
+
+
+class GbfsFeedImpl(FeedImpl, GbfsFeed):
+    """Implementation of the `GtfsFeed` model.
+    This class converts a SQLAlchemy row DB object to a Pydantic model.
+    """
+
+    class Config:
+        """Pydantic configuration.
+        Enabling `from_attributes` method to create a model instance from a SQLAlchemy row object."""
+
+        from_attributes = True
+
+    @classmethod
+    def from_orm(cls, feed: GbfsFeedOrm | None) -> GbfsFeed | None:
+        gbfs_feed: GbfsFeed = super().from_orm(feed)
+        if not gbfs_feed:
+            return None
+        gbfs_feed.locations = [LocationImpl.from_orm(item) for item in feed.locations] if feed.locations else []
+        gbfs_feed.system_id = feed.system_id
+        gbfs_feed.provider_url = feed.operator_url
+        gbfs_feed.versions = (
+            [GbfsVersionImpl.from_orm(item) for item in feed.gbfsversions if item is not None]
+            if feed.gbfsversions
+            else []
+        )
+        return gbfs_feed

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

@@ -0,0 +1,25 @@
+from feeds_gen.models.gbfs_version import GbfsValidationReport
+from shared.database_gen.sqlacodegen_models import Gbfsvalidationreport as GbfsValidationReportOrm
+
+
+class GbfsValidationReportImpl(GbfsValidationReport):
+    """Implementation of the `GtfsFeed` model.
+    This class converts a SQLAlchemy row DB object to a Pydantic model.
+    """
+
+    class Config:
+        """Pydantic configuration.
+        Enabling `from_attributes` method to create a model instance from a SQLAlchemy row object."""
+
+        from_attributes = True
+
+    @classmethod
+    def from_orm(cls, validation_report: GbfsValidationReportOrm | None) -> GbfsValidationReport | None:
+        if not validation_report:
+            return None
+        return cls(
+            validated_at=validation_report.validated_at,
+            total_error=validation_report.total_errors_count,
+            report_summary_url=validation_report.report_summary_url,
+            validator_version=validation_report.validator_version,
+        )

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

@@ -0,0 +1,36 @@
+from feeds.impl.models.gbfs_endpoint_impl import GbfsEndpointImpl
+from feeds.impl.models.gbfs_validation_report_impl import GbfsValidationReportImpl
+from feeds_gen.models.gbfs_version import GbfsVersion
+from shared.database_gen.sqlacodegen_models import Gbfsversion as GbfsVersionOrm
+
+
+class GbfsVersionImpl(GbfsVersion):
+    """Implementation of the `GtfsFeed` model.
+    This class converts a SQLAlchemy row DB object to a Pydantic model.
+    """
+
+    class Config:
+        """Pydantic configuration.
+        Enabling `from_attributes` method to create a model instance from a SQLAlchemy row object."""
+
+        from_attributes = True
+
+    @classmethod
+    def from_orm(cls, version: GbfsVersionOrm | None) -> GbfsVersion | None:
+        if not version:
+            return None
+        latest_report = (
+            GbfsValidationReportImpl.from_orm(version.gbfsvalidationreports[0])
+            if len(version.gbfsvalidationreports) > 0
+            else None
+        )
+        return cls(
+            version=version.version,
+            created_at=version.created_at,
+            last_updated_at=latest_report.validated_at if latest_report else None,
+            latest=version.latest,
+            endpoints=[GbfsEndpointImpl.from_orm(item) for item in version.gbfsendpoints]
+            if version.gbfsendpoints
+            else [],
+            latest_validation_report=latest_report,
+        )