garf-executors 0.0.7__py3-none-any.whl → 0.0.8.post0__py3-none-any.whl

garf_executors/__init__.py

@@ -15,12 +15,31 @@
 
 from __future__ import annotations
 
-from garf_executors.api_executor import ApiQueryExecutor
-from garf_executors.fetchers import FETCHERS
+from garf_executors import bq_executor, fetchers, sql_executor
+from garf_executors.api_executor import ApiExecutionContext, ApiQueryExecutor
+
+
+def setup_executor(source: str, fetcher_parameters: dict[str, str]):
+  """Initializes executors based on a source and parameters."""
+  if source == 'bq':
+    query_executor = bq_executor.BigQueryExecutor(**fetcher_parameters)
+  elif source == 'sqldb':
+    query_executor = (
+      sql_executor.SqlAlchemyQueryExecutor.from_connection_string(
+        fetcher_parameters.get('connection_string')
+      )
+    )
+  else:
+    concrete_api_fetcher = fetchers.get_report_fetcher(source)
+    query_executor = ApiQueryExecutor(
+      concrete_api_fetcher(**fetcher_parameters)
+    )
+  return query_executor
+
 
 __all__ = [
-  'FETCHERS',
   'ApiQueryExecutor',
+  'ApiExecutionContext',
 ]
 
-__version__ = '0.0.7'
+__version__ = '0.0.8.post0'

garf_executors/api_executor.py

@@ -22,48 +22,19 @@ from __future__ import annotations
 
 import logging
 
-import pydantic
-
-from garf_core import query_editor, report_fetcher
-from garf_executors import exceptions
-from garf_io import writer
-from garf_io.writers import abs_writer
+from garf_core import report_fetcher
+from garf_executors import exceptions, execution_context, executor, fetchers
 
 logger = logging.getLogger(__name__)
 
 
-class ApiExecutionContext(pydantic.BaseModel):
-  """Common context for executing one or more queries.
-
-  Attributes:
-    query_parameters: Parameters to dynamically change query text.
-    fetcher_parameters: Parameters to specify fetching setup.
-    writer: Type of writer to use.
-    writer_parameters: Optional parameters to setup writer.
-  """
+class ApiExecutionContext(execution_context.ExecutionContext):
+  """Common context for executing one or more queries."""
 
-  query_parameters: query_editor.GarfQueryParameters | None = None
-  fetcher_parameters: dict[str, str] | None = None
   writer: str = 'console'
-  writer_parameters: dict[str, str] | None = None
 
-  def model_post_init(self, __context__) -> None:
-    if self.fetcher_parameters is None:
-      self.fetcher_parameters = {}
-    if self.writer_parameters is None:
-      self.writer_parameters = {}
 
-  @property
-  def writer_client(self) -> abs_writer.AbsWriter:
-    writer_client = writer.create_writer(self.writer, **self.writer_parameters)
-    if self.writer == 'bq':
-      _ = writer_client.create_or_get_dataset()
-    if self.writer == 'sheet':
-      writer_client.init_client()
-    return writer_client
-
-
-class ApiQueryExecutor:
+class ApiQueryExecutor(executor.Executor):
   """Gets data from API and writes them to local/remote storage.
 
   Attributes:
@@ -78,16 +49,32 @@ class ApiQueryExecutor:
     """
     self.fetcher = fetcher
 
+  @classmethod
+  def from_fetcher_alias(
+    cls, source: str, fetcher_parameters: dict[str, str] | None = None
+  ) -> ApiQueryExecutor:
+    if not fetcher_parameters:
+      fetcher_parameters = {}
+    concrete_api_fetcher = fetchers.get_report_fetcher(source)
+    return ApiQueryExecutor(concrete_api_fetcher(**fetcher_parameters))
+
   async def aexecute(
-    self, query: str, context: ApiExecutionContext, **kwargs: str
+    self,
+    query: str,
+    title: str,
+    context: ApiExecutionContext,
   ) -> str:
-    """Reads query, extract results and stores them in a specified location.
+    """Performs query execution asynchronously.
 
     Args:
       query: Location of the query.
+      title: Name of the query.
       context: Query execution context.
+
+    Returns:
+      Result of writing the report.
     """
-    await self.execute(query, context, **kwargs)
+    return await self.execute(query, context, title, context)
 
   def execute(
     self,

garf_executors/bq_executor.py

@@ -11,10 +11,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-"""Module for executing queries in BigQuery."""
+"""Executes queries in BigQuery."""
 
 from __future__ import annotations
 
+import os
+
 try:
   from google.cloud import bigquery  # type: ignore
 except ImportError as e:
@@ -25,19 +27,19 @@ except ImportError as e:
 
 import logging
 
-import pandas as pd
 from google.cloud import exceptions as google_cloud_exceptions
 
-from garf_core import query_editor
+from garf_core import query_editor, report
+from garf_executors import exceptions, execution_context, executor
 
 logger = logging.getLogger(__name__)
 
 
-class BigQueryExecutorError(Exception):
-  """Error when executor fails to run query."""
+class BigQueryExecutorError(exceptions.GarfExecutorError):
+  """Error when BigQueryExecutor fails to run query."""
 
 
-class BigQueryExecutor(query_editor.TemplateProcessorMixin):
+class BigQueryExecutor(executor.Executor, query_editor.TemplateProcessorMixin):
   """Handles query execution in BigQuery.
 
   Attributes:
@@ -46,13 +48,22 @@ class BigQueryExecutor(query_editor.TemplateProcessorMixin):
       client: BigQuery client.
   """
 
-  def __init__(self, project_id: str, location: str | None = None) -> None:
+  def __init__(
+    self,
+    project_id: str | None = os.getenv('GOOGLE_CLOUD_PROJECT'),
+    location: str | None = None,
+  ) -> None:
     """Initializes BigQueryExecutor.
 
     Args:
         project_id: Google Cloud project id.
         location: BigQuery dataset location.
     """
+    if not project_id:
+      raise BigQueryExecutorError(
+        'project_id is required. Either provide it as project_id parameter '
+        'or GOOGLE_CLOUD_PROJECT env variable.'
+      )
     self.project_id = project_id
     self.location = location
 
@@ -62,26 +73,48 @@ class BigQueryExecutor(query_editor.TemplateProcessorMixin):
     return bigquery.Client(self.project_id)
 
   def execute(
-    self, script_name: str, query_text: str, params: dict | None = None
-  ) -> pd.DataFrame:
+    self,
+    query: str,
+    title: str,
+    context: execution_context.ExecutionContext = (
+      execution_context.ExecutionContext()
+    ),
+  ) -> report.GarfReport:
     """Executes query in BigQuery.
 
     Args:
-        script_name: Script identifier.
-        query_text: Query to be executed.
-        params: Optional parameters to be replaced in query text.
+      query: Location of the query.
+      title: Name of the query.
+      context: Query execution context.
 
     Returns:
-        DataFrame if query returns some data otherwise empty DataFrame.
+      Report with data if query returns some data otherwise empty Report.
     """
-    query_text = self.replace_params_template(query_text, params)
+    query_text = self.replace_params_template(query, context.query_parameters)
     job = self.client.query(query_text)
     try:
       result = job.result()
-      logger.debug('%s launched successfully', script_name)
+      logger.debug('%s launched successfully', title)
       if result.total_rows:
-        return result.to_dataframe()
-      return pd.DataFrame()
+        results = report.GarfReport.from_pandas(result.to_dataframe())
+      else:
+        results = report.GarfReport()
+      if context.writer and results:
+        writer_client = context.writer_client
+        logger.debug(
+          'Start writing data for query %s via %s writer',
+          title,
+          type(writer_client),
+        )
+        writing_result = writer_client.write(results, title)
+        logger.debug(
+          'Finish writing data for query %s via %s writer',
+          title,
+          type(writer_client),
+        )
+        logger.info('%s executed successfully', title)
+        return writing_result
+      return results
     except google_cloud_exceptions.GoogleCloudError as e:
       raise BigQueryExecutorError(e) from e
 
@@ -92,7 +125,7 @@ class BigQueryExecutor(query_editor.TemplateProcessorMixin):
     are treated as dataset names.
 
     Args:
-        macros: Mapping containing data for query execution.
+      macros: Mapping containing data for query execution.
     """
     if macros and (datasets := extract_datasets(macros)):
       for dataset in datasets:

garf_executors/entrypoints/cli.py

@@ -21,7 +21,6 @@ from __future__ import annotations
 
 import argparse
 import sys
-from concurrent import futures
 
 import garf_executors
 from garf_executors import exceptions
@@ -56,13 +55,6 @@ def main():
   if args.version:
     print(garf_executors.__version__)
     sys.exit()
-  if not (source := args.source):
-    raise exceptions.GarfExecutorError(
-      f'Select one of available sources: {list(garf_executors.FETCHERS.keys())}'
-    )
-  if not (concrete_api_fetcher := garf_executors.FETCHERS.get(source)):
-    raise exceptions.GarfExecutorError(f'Source {source} is not available.')
-
   logger = utils.init_logging(
     loglevel=args.loglevel.upper(), logger_type=args.logger
   )
@@ -88,23 +80,13 @@ def main():
     writer_parameters=config.writer_params,
     fetcher_parameters=source_parameters,
   )
-  query_executor = garf_executors.api_executor.ApiQueryExecutor(
-    concrete_api_fetcher(**source_parameters)
+  query_executor = garf_executors.setup_executor(
+    args.source, context.fetcher_parameters
   )
   if args.parallel_queries:
     logger.info('Running queries in parallel')
-    with futures.ThreadPoolExecutor(args.parallel_threshold) as executor:
-      future_to_query = {
-        executor.submit(
-          query_executor.execute,
-          reader_client.read(query),
-          query,
-          context,
-        ): query
-        for query in args.query
-      }
-      for future in futures.as_completed(future_to_query):
-        future.result()
+    batch = {query: reader_client.read(query) for query in args.query}
+    query_executor.execute_batch(batch, context, args.parallel_queries)
   else:
     logger.info('Running queries sequentially')
     for query in args.query:

garf_executors/entrypoints/server.py

@@ -37,8 +37,8 @@ class ApiExecutorRequest(pydantic.BaseModel):
   source: str
   title: str | None = None
   query: str | None = None
-  query_path: str | None = None
-  context: garf_executors.api_executor.ApiExecutionContext
+  query_path: str | list[str] | None = None
+  context: garf_executors.ApiExecutionContext
 
   @pydantic.model_validator(mode='after')
   def check_query_specified(self):
@@ -49,31 +49,43 @@ class ApiExecutorRequest(pydantic.BaseModel):
     return self
 
   def model_post_init(self, __context__) -> None:
-    if self.query_path:
+    if self.query_path and isinstance(self.query_path, str):
       self.query = reader.FileReader().read(self.query_path)
     if not self.title:
       self.title = str(self.query_path)
 
 
+class ApiExecutorResponse(pydantic.BaseModel):
+  """Response after executing a query.
+
+  Attributes:
+    results: Results of query execution.
+  """
+
+  results: list[str]
+
+
 router = fastapi.APIRouter(prefix='/api')
 
 
 @router.post('/execute')
-async def execute(request: ApiExecutorRequest) -> dict[str, str]:
-  if not (concrete_api_fetcher := garf_executors.FETCHERS.get(request.source)):
-    raise exceptions.GarfExecutorError(
-      f'Source {request.source} is not available.'
-    )
-
-  query_executor = garf_executors.api_executor.ApiQueryExecutor(
-    concrete_api_fetcher(**request.context.fetcher_parameters)
+async def execute(request: ApiExecutorRequest) -> ApiExecutorResponse:
+  query_executor = garf_executors.setup_executor(
+    request.source, request.context.fetcher_parameters
   )
-
   result = query_executor.execute(request.query, request.title, request.context)
+  return ApiExecutorResponse(results=[result])
+
 
-  return fastapi.responses.JSONResponse(
-    content=fastapi.encoders.jsonable_encoder({'result': result})
+@router.post('/execute:batch')
+async def execute_batch(request: ApiExecutorRequest) -> ApiExecutorResponse:
+  query_executor = garf_executors.setup_executor(
+    request.source, request.context.fetcher_parameters
   )
+  reader_client = reader.FileReader()
+  batch = {query: reader_client.read(query) for query in request.query_path}
+  results = query_executor.execute_batch(batch, request.context)
+  return ApiExecutorResponse(results=results)
 
 
 if __name__ == '__main__':

garf_executors/execution_context.py

@@ -0,0 +1,60 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pylint: disable=C0330, g-bad-import-order, g-multiple-import
+
+from __future__ import annotations
+
+import pydantic
+
+from garf_core import query_editor
+from garf_io import writer
+from garf_io.writers import abs_writer
+
+
+class ExecutionContext(pydantic.BaseModel):
+  """Common context for executing one or more queries.
+
+  Attributes:
+    query_parameters: Parameters to dynamically change query text.
+    fetcher_parameters: Parameters to specify fetching setup.
+    writer: Type of writer to use.
+    writer_parameters: Optional parameters to setup writer.
+  """
+
+  query_parameters: query_editor.GarfQueryParameters | None = pydantic.Field(
+    default_factory=dict
+  )
+  fetcher_parameters: dict[str, str] | None = pydantic.Field(
+    default_factory=dict
+  )
+  writer: str | None = None
+  writer_parameters: dict[str, str] | None = pydantic.Field(
+    default_factory=dict
+  )
+
+  def model_post_init(self, __context__) -> None:
+    if self.fetcher_parameters is None:
+      self.fetcher_parameters = {}
+    if self.writer_parameters is None:
+      self.writer_parameters = {}
+
+  @property
+  def writer_client(self) -> abs_writer.AbsWriter:
+    writer_client = writer.create_writer(self.writer, **self.writer_parameters)
+    if self.writer == 'bq':
+      _ = writer_client.create_or_get_dataset()
+    if self.writer == 'sheet':
+      writer_client.init_client()
+    return writer_client

garf_executors/executor.py

@@ -0,0 +1,54 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Defines common functionality between executors."""
+
+from concurrent import futures
+
+from garf_executors import execution_context
+
+
+class Executor:
+  """Defines common functionality between executors."""
+
+  def execute_batch(
+    self,
+    batch: dict[str, str],
+    context: execution_context.ExecutionContext,
+    parallel_threshold: int = 10,
+  ) -> list[str]:
+    """Executes batch of queries for a common context.
+
+    Args:
+      batch: Mapping between query_title and its text.
+      context: Execution context.
+      parallel_threshold: Number of queries to execute in parallel.
+
+    Returns:
+      Results of execution.
+    """
+    results = []
+    with futures.ThreadPoolExecutor(max_workers=parallel_threshold) as executor:
+      future_to_query = {
+        executor.submit(
+          self.execute,
+          query,
+          title,
+          context,
+        ): query
+        for title, query in batch.items()
+      }
+      for future in futures.as_completed(future_to_query):
+        results.append(future.result())
+    return results

garf_executors/fetchers.py

@@ -15,23 +15,41 @@
 import inspect
 from importlib.metadata import entry_points
 
-from garf_core import report_fetcher
+from garf_core import exceptions, report_fetcher
 
 
-def get_report_fetchers() -> dict[str, report_fetcher.ApiReportFetcher]:
+def find_fetchers() -> set[str]:
+  """Identifiers all available report fetchers."""
+  return {fetcher.name for fetcher in entry_points(group='garf')}
+
+
+def get_report_fetcher(source: str) -> type[report_fetcher.ApiReportFetcher]:
+  """Loads report fetcher for a given source.
+
+  Args:
+    source: Alias for a source associated with a fetcher.
+
+  Returns:
+    Class for a found report fetcher.
+
+  Raises:
+    ApiReportFetcherError: When fetcher cannot be loaded.
+    MissingApiReportFetcherError: When fetcher not found.
+  """
+  if source not in find_fetchers():
+    raise report_fetcher.MissingApiReportFetcherError(source)
   fetchers = entry_points(group='garf')
-  found_fetchers = {}
   for fetcher in fetchers:
-    try:
-      fetcher_module = fetcher.load()
-      for name, obj in inspect.getmembers(fetcher_module):
-        if inspect.isclass(obj) and issubclass(
-          obj, report_fetcher.ApiReportFetcher
-        ):
-          found_fetchers[fetcher.name] = getattr(fetcher_module, name)
-    except ModuleNotFoundError:
-      continue
-  return found_fetchers
-
-
-FETCHERS = get_report_fetchers()
+    if fetcher.name == source:
+      try:
+        fetcher_module = fetcher.load()
+        for name, obj in inspect.getmembers(fetcher_module):
+          if inspect.isclass(obj) and issubclass(
+            obj, report_fetcher.ApiReportFetcher
+          ):
+            return getattr(fetcher_module, name)
+      except ModuleNotFoundError:
+        continue
+  raise exceptions.ApiReportFetcherError(
+    f'No fetcher available for the source "{source}"'
+  )

garf_executors/sql_executor.py

@@ -25,14 +25,22 @@ except ImportError as e:
 
 import logging
 import re
-from typing import Any
 
 import pandas as pd
 
-from garf_core import query_editor
+from garf_core import query_editor, report
+from garf_executors import exceptions, execution_context, executor
 
+logger = logging.getLogger(__name__)
 
-class SqlAlchemyQueryExecutor(query_editor.TemplateProcessorMixin):
+
+class SqlAlchemyQueryExecutorError(exceptions.GarfExecutorError):
+  """Error when SqlAlchemyQueryExecutor fails to run query."""
+
+
+class SqlAlchemyQueryExecutor(
+  executor.Executor, query_editor.TemplateProcessorMixin
+):
   """Handles query execution via SqlAlchemy.
 
   Attributes:
@@ -51,36 +59,60 @@ class SqlAlchemyQueryExecutor(query_editor.TemplateProcessorMixin):
   def from_connection_string(
     cls, connection_string: str
   ) -> SqlAlchemyQueryExecutor:
+    """Creates executor from SqlAlchemy connection string.
+
+    https://docs.sqlalchemy.org/en/20/core/engines.html
+    """
     engine = sqlalchemy.create_engine(connection_string)
     return cls(engine)
 
   def execute(
     self,
-    script_name: str | None,
-    query_text: str,
-    params: dict[str, Any] | None = None,
-  ) -> pd.DataFrame:
+    query: str,
+    title: str,
+    context: execution_context.ExecutionContext = (
+      execution_context.ExecutionContext()
+    ),
+  ) -> report.GarfReport:
     """Executes query in a given database via SqlAlchemy.
 
     Args:
-        script_name: Script identifier.
-        query_text: Query to be executed.
-        params: Optional parameters to be replaced in query text.
+      query: Location of the query.
+      title: Name of the query.
+      context: Query execution context.
 
     Returns:
-        DataFrame if query returns some data otherwise empty DataFrame.
+      Report with data if query returns some data otherwise empty Report.
     """
-    logging.info('Executing script: %s', script_name)
-    query_text = self.replace_params_template(query_text, params)
+    logging.info('Executing script: %s', title)
+    query_text = self.replace_params_template(query, context.query_parameters)
     with self.engine.begin() as conn:
       if re.findall(r'(create|update) ', query_text.lower()):
         conn.connection.executescript(query_text)
-        return pd.DataFrame()
-      temp_table_name = f'temp_{script_name}'.replace('.', '_')
-      query_text = f'CREATE TABLE {temp_table_name} AS {query_text}'
-      conn.connection.executescript(query_text)
-      try:
-        result = pd.read_sql(f'SELECT * FROM {temp_table_name}', conn)
-      finally:
-        conn.connection.execute(f'DROP TABLE {temp_table_name}')
-      return result
+        results = report.GarfReport()
+      else:
+        temp_table_name = f'temp_{title}'.replace('.', '_')
+        query_text = f'CREATE TABLE {temp_table_name} AS {query_text}'
+        conn.connection.executescript(query_text)
+        try:
+          results = report.GarfReport.from_pandas(
+            pd.read_sql(f'SELECT * FROM {temp_table_name}', conn)
+          )
+        finally:
+          conn.connection.execute(f'DROP TABLE {temp_table_name}')
+      if context.writer and results:
+        writer_client = context.writer_client
+        logger.debug(
+          'Start writing data for query %s via %s writer',
+          title,
+          type(writer_client),
+        )
+        writing_result = writer_client.write(results, title)
+        logger.debug(
+          'Finish writing data for query %s via %s writer',
+          title,
+          type(writer_client),
+        )
+        logger.info('%s executed successfully', title)
+        return writing_result
+      return results

{garf_executors-0.0.7.dist-info → garf_executors-0.0.8.post0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: garf-executors
-Version: 0.0.7
+Version: 0.0.8.post0
 Summary: Executes queries against API and writes data to local/remote storage.
 Author-email: "Google Inc. (gTech gPS CSE team)" <no-reply@google.com>, Andrei Markin <andrey.markin.ppc@gmail.com>
 License: Apache 2.0

garf_executors-0.0.8.post0.dist-info/RECORD

@@ -0,0 +1,17 @@
+garf_executors/__init__.py,sha256=Xc2IDryx7-Nw7V16v93k9HEGxG51zxLDcN9xp8CQRO4,1514
+garf_executors/api_executor.py,sha256=kMiy7PyjCvUDm1sFbW6SOXhrXFZFamL1XPLkg-aYqN8,3572
+garf_executors/bq_executor.py,sha256=XRik48P7aQkoLpABzWzEX2t3ktQVPrXp2v7Zdu8qWVI,4802
+garf_executors/exceptions.py,sha256=U_7Q2ZMOUf89gzZd2pw7y3g7i1NeByPPKfpZ3q7p3ZU,662
+garf_executors/execution_context.py,sha256=0PYYnwkwBJ2B1HpNN5MrANZkIbuzyxH7EzEjUPf0GGA,1966
+garf_executors/executor.py,sha256=bGTGlWZT5B7I_WIjhuQ0CkL7Dij_ijFCBxuC1jGVkng,1626
+garf_executors/fetchers.py,sha256=m2feJ6ByYq-oJXuQ3tmaNMx7soMcGsVC2hY4kOsPaNQ,1833
+garf_executors/sql_executor.py,sha256=vG3-FM4C1O0rVwFMPIw85xoErsnTBYoVhMTgt9jP3QM,3699
+garf_executors/entrypoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+garf_executors/entrypoints/cli.py,sha256=ZGwDQ2V6hYMjaVVcNDrAyvagrAET8X1kXFfD2gSG4BI,3455
+garf_executors/entrypoints/server.py,sha256=MEEPxcIfy_PeDuz8oJ7wIZVUcz0q54mW0y89x5I_VgM,2821
+garf_executors/entrypoints/utils.py,sha256=p483h5RY_kfwOhNq2RqwMnunOoTGXGA59nCyHY_Lvgg,15057
+garf_executors-0.0.8.post0.dist-info/METADATA,sha256=z5oroJiy5YtdrVXhMbZlJ5Rv9yzx7ZtJGxIoyXFp2d0,2654
+garf_executors-0.0.8.post0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+garf_executors-0.0.8.post0.dist-info/entry_points.txt,sha256=LskWNFIw8j0WJuI18-32OZrlASXAMg1XtrRYwsKBz2E,61
+garf_executors-0.0.8.post0.dist-info/top_level.txt,sha256=sP4dCXOENPn1hDFAunjMV8Js4NND_KGeO_gQWuaT0EY,15
+garf_executors-0.0.8.post0.dist-info/RECORD,,

garf_executors-0.0.7.dist-info/RECORD

@@ -1,15 +0,0 @@
-garf_executors/__init__.py,sha256=PK4dnVynkPmJi8EGUYwbv4lwQ2ELO_cTO8FQaZV3VXA,858
-garf_executors/api_executor.py,sha256=HOIBg-bILtLNHqtiklZio5h5xXNwVAuZMIRJTL7_5_U,4104
-garf_executors/bq_executor.py,sha256=JBPxbDRYgUgpJv6SqYiFPypTFjZGIZ-SOOb6dS2sZQY,3822
-garf_executors/exceptions.py,sha256=U_7Q2ZMOUf89gzZd2pw7y3g7i1NeByPPKfpZ3q7p3ZU,662
-garf_executors/fetchers.py,sha256=gkAKHsDPzJySg4wYLZeCmNINtk6f17-jFzOP7tE82r8,1226
-garf_executors/sql_executor.py,sha256=6tpsd1Ive5igAlQuhCSkli-tZHp58uWAU86JWGvdVpE,2722
-garf_executors/entrypoints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-garf_executors/entrypoints/cli.py,sha256=mWvPQkaqarDj5byHRvNAweVbUQiHZLXrC-35zY7l4fs,4043
-garf_executors/entrypoints/server.py,sha256=CALlrRaKiKFOvsE1uQyjtz2UxqEeh_QqR5nBMQgMjCs,2430
-garf_executors/entrypoints/utils.py,sha256=p483h5RY_kfwOhNq2RqwMnunOoTGXGA59nCyHY_Lvgg,15057
-garf_executors-0.0.7.dist-info/METADATA,sha256=NBFu6iIeYifvVVMCJOr_o9GpMAEp5aMBdnK4cW5FlEs,2648
-garf_executors-0.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-garf_executors-0.0.7.dist-info/entry_points.txt,sha256=LskWNFIw8j0WJuI18-32OZrlASXAMg1XtrRYwsKBz2E,61
-garf_executors-0.0.7.dist-info/top_level.txt,sha256=sP4dCXOENPn1hDFAunjMV8Js4NND_KGeO_gQWuaT0EY,15
-garf_executors-0.0.7.dist-info/RECORD,,