[core] feat: add support for generating results_placeholder

Author: AndreyMarkinPPC

libs/community/google/ads/garf_google_ads/api_clients.py

@@ -91,6 +91,14 @@ def __init__(
     self.ads_service = self.client.get_service('GoogleAdsService')
     self.kwargs = kwargs
 
+  def _get_google_ads_row(self) -> google_ads_service.GoogleAdsRow:
+    """Gets GoogleAdsRow proto message for a given API version."""
+    google_ads_service = importlib.import_module(
+      f'google.ads.googleads.{self.api_version}.'
+      f'services.types.google_ads_service'
+    )
+    return google_ads_service.GoogleAdsRow()
+
   @override
   @tenacity.retry(
     stop=tenacity.stop_after_attempt(3),
@@ -103,24 +111,14 @@ def __init__(
   def get_response(
     self, request: query_editor.GoogleAdsApiQuery, account: int, **kwargs: str
   ) -> api_clients.GarfApiResponse:
-    """Executes query for a given entity_id (customer_id).
-
-    Args:
-        account: Google Ads customer_id.
-        query_text: GAQL query text.
-
-    Returns:
-        SearchGoogleAdsStreamResponse for a given API version.
-
-    Raises:
-        google_exceptions.InternalServerError:
-            When data cannot be fetched from Ads API.
-    """
+    """Executes a single API request for a given customer_id and GAQL query."""
     response = self.ads_service.search_stream(
       customer_id=account, query=request.text
     )
     results = [result for batch in response for result in batch.results]
-    return api_clients.GarfApiResponse(results=results)
+    return api_clients.GarfApiResponse(
+      results=results, results_placeholder=[self._get_google_ads_row()]
+    )
 
   def _init_client(
     self,

libs/community/google/youtube/youtube-data-api/garf_youtube_data_api/api_clients.py

@@ -72,6 +72,47 @@ def service(self):
       return self._service
     return build('youtube', self.api_version, developerKey=self.api_key)
 
+  def infer_types(self, service, name, fields):
+    results = {}
+    ress = service._schema.schemas.get(name)
+    props = ress.get('properties')
+    for field in fields:
+      if prop := props.get(field):
+        if ref := prop.get('$ref'):
+          results[field] = self.infer_types(service, ref, [field])
+        else:
+          results[field] = prop.get('type') or prop.get('type')
+      else:
+        results.update(
+          {k: v.get('format') or v.get('type') for k, v in props.items()}
+        )
+    return results
+
+  def generate_sample_values(self, types):
+    results = {}
+    type_mapping = {
+      'string': '',
+      'int64': 1,
+      'int32': 1,
+      'uint64': 1,
+      'uint32': 1,
+      'double': 1.0,
+      'boolean': True,
+      'date-time': '2024-01-01',
+      'google-datetime': '2024-01-01T',
+      'google-duration': '2H',
+    }
+    for key, value in types.items():
+      if isinstance(value, dict):
+        results[key] = self.generate_sample_values(value)
+      else:
+        results[key] = type_mapping.get(value)
+    return results
+
+  def simulate(self, service, name, fields):
+    types = self.infer_types(service, name, fields)
+    return self.generate_sample_values(types)
+
   @override
   @telemetry.tracer.start_as_current_span('youtube_data_api.get_response')
   def get_response(
@@ -80,9 +121,12 @@ def get_response(
     span = trace.get_current_span()
     for k, v in kwargs.items():
       span.set_attribute(f'youtube_data_api.kwargs.{k}', v)
-    fields = [field.split('.')[0] for field in request.fields]
+    fields = {field.split('.')[0] for field in request.fields}
     sub_service = getattr(self.service, request.resource_name)()
     part_str = ','.join(fields)
+
+    sim_res = self.simulate(sub_service, 'Video', fields)
+
     result = self._list(sub_service, part=part_str, **kwargs)
     results = []
     if data := result.get('items'):
@@ -129,8 +173,12 @@ def get_response(
               break
           if include_row:
             filtered_results.append(row)
-      return api_clients.GarfApiResponse(results=filtered_results)
-    return api_clients.GarfApiResponse(results=results)
+      return api_clients.GarfApiResponse(
+        results=filtered_results, results_placeholder=[sim_res]
+      )
+    return api_clients.GarfApiResponse(
+      results=results, results_placeholder=[sim_res]
+    )
 
   def _list(
     self, service, part: str, next_page_token: str | None = None, **kwargs

libs/core/garf_core/api_clients.py

@@ -40,6 +40,9 @@ class GarfApiResponse(pydantic.BaseModel):
   """Base class for specifying response."""
 
   results: list[ApiResponseRow | Any]
+  results_placeholder: list[ApiResponseRow | Any] = pydantic.Field(
+    default_factory=list
+  )
 
   def __bool__(self) -> bool:
     return bool(self.results)
@@ -100,17 +103,27 @@ def get_response(
 class FakeApiClient(BaseClient):
   """Fake class for specifying API client."""
 
-  def __init__(self, results: Sequence[dict[str, Any]], **kwargs: str) -> None:
+  def __init__(
+    self,
+    results: Sequence[dict[str, Any]],
+    results_placeholder: Sequence[dict[str, Any]] | None = None,
+    **kwargs: str,
+  ) -> None:
     """Initializes FakeApiClient."""
     self.results = list(results)
+    self.results_placeholder = (
+      [] if not results_placeholder else list(results_placeholder)
+    )
     self.kwargs = kwargs
 
   @override
   def get_response(
     self, request: query_editor.BaseQueryElements, **kwargs: str
   ) -> GarfApiResponse:
     del request
-    return GarfApiResponse(results=self.results)
+    return GarfApiResponse(
+      results=self.results, results_placeholder=self.results_placeholder
+    )
 
   @classmethod
   def from_file(cls, file_location: str | os.PathLike[str]) -> FakeApiClient:

libs/core/garf_core/report_fetcher.py

@@ -181,7 +181,14 @@ def fetch(
         logger.info('Cached version not found, generating')
     response = self.api_client.call_api(query, **kwargs)
     if not response:
-      return report.GarfReport(query_specification=query)
+      placeholder_parsed_response = self.parser(query).parse_response(
+        api_clients.GarfApiResponse(results=response.results_placeholder)
+      )
+      return report.GarfReport(
+        query_specification=query,
+        results_placeholder=placeholder_parsed_response,
+        column_names=[c for c in query.column_names if c != '_'],
+      )
 
     parsed_response = self.parser(query).parse_response(response)
     fetched_report = report.GarfReport(

libs/core/tests/unit/test_report_fetcher.py

@@ -159,3 +159,46 @@ def test_fetch_parses_virtual_columns(self, test_dict_report_fetcher):
     )
 
     assert test_report == expected_report
+
+  def test_fetch_returns_results_placeholder_when_missing_results(self):
+    test_api_client = api_clients.FakeApiClient(
+      results=[],
+      results_placeholder=[
+        {'column': {'name': 1}, 'other_column': 2},
+      ],
+    )
+    test_fetcher = report_fetcher.ApiReportFetcher(
+      api_client=test_api_client, parser=parsers.DictParser
+    )
+
+    query = """
+      SELECT
+        column.name,
+        other_column,
+        0 AS constant_column,
+        column.name + other_column AS calculated_column,
+        'http://example.com/' + column.name AS concat_column,
+        '{current_date}' AS magic_column
+      FROM test
+    """
+    test_report = test_fetcher.fetch(query)
+
+    current_date = datetime.date.today().strftime('%Y-%m-%d')
+    expected_report = report.GarfReport(
+      results_placeholder=[
+        [1, 2, 0, 1 + 2, 'http://example.com/1', current_date],
+      ],
+      column_names=[
+        'column_name',
+        'other_column',
+        'constant_column',
+        'calculated_column',
+        'concat_column',
+        'magic_column',
+      ],
+    )
+
+    assert (test_report.results_placeholder, test_report.column_names) == (
+      expected_report.results_placeholder,
+      expected_report.column_names,
+    )