garf-executors 0.2.3__py3-none-any.whl → 1.0.2__py3-none-any.whl

garf_executors/bq_executor.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Google LLC
+# Copyright 2026 Google LLC
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,167 +11,15 @@
 # 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.
-"""Executes queries in BigQuery."""
 
-from __future__ import annotations
 
-import contextlib
-import os
+import warnings
 
-try:
-  from google.cloud import bigquery  # type: ignore
-except ImportError as e:
-  raise ImportError(
-    'Please install garf-executors with BigQuery support '
-    '- `pip install garf-executors[bq]`'
-  ) from e
+from garf.executors.bq_executor import *
 
-import logging
-
-from garf_core import query_editor, report
-from google.cloud import exceptions as google_cloud_exceptions
-from opentelemetry import trace
-
-from garf_executors import exceptions, execution_context, executor
-from garf_executors.telemetry import tracer
-
-logger = logging.getLogger(__name__)
-
-
-class BigQueryExecutorError(exceptions.GarfExecutorError):
-  """Error when BigQueryExecutor fails to run query."""
-
-
-class BigQueryExecutor(executor.Executor, query_editor.TemplateProcessorMixin):
-  """Handles query execution in BigQuery.
-
-  Attributes:
-      project_id: Google Cloud project id.
-      location: BigQuery dataset location.
-      client: BigQuery client.
-  """
-
-  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
-    super().__init__()
-
-  @property
-  def client(self) -> bigquery.Client:
-    """Instantiates bigquery client."""
-    return bigquery.Client(self.project_id)
-
-  @tracer.start_as_current_span('bq.execute')
-  def execute(
-    self,
-    query: str,
-    title: str,
-    context: execution_context.ExecutionContext = (
-      execution_context.ExecutionContext()
-    ),
-  ) -> report.GarfReport:
-    """Executes query in BigQuery.
-
-    Args:
-      query: Location of the query.
-      title: Name of the query.
-      context: Query execution context.
-
-    Returns:
-      Report with data if query returns some data otherwise empty Report.
-    """
-    span = trace.get_current_span()
-    logger.info('Executing script: %s', title)
-    query_text = self.replace_params_template(query, context.query_parameters)
-    self.create_datasets(context.query_parameters.macro)
-    job = self.client.query(query_text)
-    try:
-      result = job.result()
-    except google_cloud_exceptions.GoogleCloudError as e:
-      raise BigQueryExecutorError(
-        f'Failed to execute query {title}: Reason: {e}'
-      ) from e
-      logger.debug('%s launched successfully', title)
-    if result.total_rows:
-      results = report.GarfReport.from_pandas(result.to_dataframe())
-    else:
-      results = report.GarfReport()
-    if context.writer and results:
-      writer_clients = context.writer_clients
-      if not writer_clients:
-        logger.warning('No writers configured, skipping write operation')
-      else:
-        writing_results = []
-        for writer_client in writer_clients:
-          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),
-          )
-          writing_results.append(writing_result)
-        # Return the last writer's result for backward compatibility
-        logger.info('%s executed successfully', title)
-        return writing_results[-1] if writing_results else None
-    logger.info('%s executed successfully', title)
-    span.set_attribute('execute.num_results', len(results))
-    return results
-
-  @tracer.start_as_current_span('bq.create_datasets')
-  def create_datasets(self, macros: dict | None) -> None:
-    """Creates datasets in BQ based on values in a dict.
-
-    If dict contains keys with 'dataset' in them, then values for such keys
-    are treated as dataset names.
-
-    Args:
-      macros: Mapping containing data for query execution.
-    """
-    if macros and (datasets := extract_datasets(macros)):
-      for dataset in datasets:
-        dataset_id = f'{self.project_id}.{dataset}'
-        try:
-          self.client.get_dataset(dataset_id)
-        except google_cloud_exceptions.NotFound:
-          bq_dataset = bigquery.Dataset(dataset_id)
-          bq_dataset.location = self.location
-          with contextlib.suppress(google_cloud_exceptions.Conflict):
-            self.client.create_dataset(bq_dataset, timeout=30)
-            logger.info('Created new dataset %s', dataset_id)
-
-
-def extract_datasets(macros: dict | None) -> list[str]:
-  """Finds dataset-related keys based on values in a dict.
-
-  If dict contains keys with 'dataset' in them, then values for such keys
-  are treated as dataset names.
-
-  Args:
-      macros: Mapping containing data for query execution.
-
-  Returns:
-      Possible names of datasets.
-  """
-  if not macros:
-    return []
-  return [value for macro, value in macros.items() if 'dataset' in macro]
+warnings.warn(
+  "The 'garf_executors' namespace is deprecated. "
+  "Please use 'garf.executors' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/config.py

@@ -1,4 +1,4 @@
-# Copyright 2025 Google LLC
+# Copyright 2026 Google LLC
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,42 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=C0330, g-bad-import-order, g-multiple-import
 
-"""Stores mapping between API aliases and their execution context."""
+import warnings
 
-from __future__ import annotations
+from garf.executors.config import *
 
-import os
-import pathlib
-
-import pydantic
-import smart_open
-import yaml
-
-from garf_executors.execution_context import ExecutionContext
-
-
-class Config(pydantic.BaseModel):
-  """Stores necessary parameters for one or multiple API sources.
-
-  Attributes:
-    source: Mapping between API source alias and execution parameters.
-  """
-
-  sources: dict[str, ExecutionContext]
-
-  @classmethod
-  def from_file(cls, path: str | pathlib.Path | os.PathLike[str]) -> Config:
-    """Builds config from local or remote yaml file."""
-    with smart_open.open(path, 'r', encoding='utf-8') as f:
-      data = yaml.safe_load(f)
-    return Config(sources=data)
-
-  def save(self, path: str | pathlib.Path | os.PathLike[str]) -> str:
-    """Saves config to local or remote yaml file."""
-    with smart_open.open(path, 'w', encoding='utf-8') as f:
-      yaml.dump(
-        self.model_dump(exclude_none=True).get('sources'), f, encoding='utf-8'
-      )
-    return f'Config is saved to {str(path)}'
+warnings.warn(
+  "The 'garf_executors' namespace is deprecated. "
+  "Please use 'garf.executors' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/entrypoints/__init__.py

@@ -0,0 +1,25 @@
+# Copyright 2026 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.
+
+
+import warnings
+
+from garf.executors.entrypoints import *
+
+warnings.warn(
+  "The 'garf_executors.entrypoints' namespace is deprecated. "
+  "Please use 'garf.executors.entrypoints' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/entrypoints/cli.py

@@ -1,4 +1,4 @@
-# Copyright 2025 Google LLC
+# Copyright 2026 Google LLC
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,154 +11,15 @@
 # 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 defining `garf` CLI utility.
 
-`garf` allows to execute queries and store results in local/remote
-storage.
-"""
 
-from __future__ import annotations
+import warnings
 
-import argparse
-import logging
-import sys
+from garf.executors.entrypoints.cli import *
 
-from garf_io import reader
-from opentelemetry import trace
-
-import garf_executors
-from garf_executors import config, exceptions, workflow
-from garf_executors.entrypoints import utils
-from garf_executors.entrypoints.tracer import initialize_tracer
-from garf_executors.telemetry import tracer
-
-initialize_tracer()
-
-
-@tracer.start_as_current_span('garf.entrypoints.cli')
-def main():
-  parser = argparse.ArgumentParser()
-  parser.add_argument('query', nargs='*')
-  parser.add_argument('-c', '--config', dest='config', default=None)
-  parser.add_argument('-w', '--workflow', dest='workflow', default=None)
-  parser.add_argument('--source', dest='source', default=None)
-  parser.add_argument('--output', dest='output', default='console')
-  parser.add_argument('--input', dest='input', default='file')
-  parser.add_argument('--log', '--loglevel', dest='loglevel', default='info')
-  parser.add_argument('--logger', dest='logger', default='local')
-  parser.add_argument('--log-name', dest='log_name', default='garf')
-  parser.add_argument(
-    '--parallel-queries', dest='parallel_queries', action='store_true'
-  )
-  parser.add_argument(
-    '--no-parallel-queries', dest='parallel_queries', action='store_false'
-  )
-  parser.add_argument('--dry-run', dest='dry_run', action='store_true')
-  parser.add_argument('-v', '--version', dest='version', action='store_true')
-  parser.add_argument(
-    '--parallel-threshold', dest='parallel_threshold', default=10, type=int
-  )
-  parser.add_argument(
-    '--enable-cache', dest='enable_cache', action='store_true'
-  )
-  parser.add_argument(
-    '--cache-ttl-seconds',
-    dest='cache_ttl_seconds',
-    default=3600,
-    type=int,
-  )
-  parser.set_defaults(parallel_queries=True)
-  parser.set_defaults(enable_cache=False)
-  parser.set_defaults(dry_run=False)
-  args, kwargs = parser.parse_known_args()
-
-  span = trace.get_current_span()
-  command_args = ' '.join(sys.argv[1:])
-  span.set_attribute('cli.command', f'garf {command_args}')
-  if args.version:
-    print(garf_executors.__version__)
-    sys.exit()
-  logger = utils.init_logging(
-    loglevel=args.loglevel.upper(), logger_type=args.logger, name=args.log_name
-  )
-  reader_client = reader.create_reader(args.input)
-  if workflow_file := args.workflow:
-    execution_workflow = workflow.Workflow.from_file(workflow_file)
-    for i, step in enumerate(execution_workflow.steps, 1):
-      with tracer.start_as_current_span(f'{i}-{step.fetcher}'):
-        query_executor = garf_executors.setup_executor(
-          source=step.fetcher,
-          fetcher_parameters=step.fetcher_parameters,
-          enable_cache=args.enable_cache,
-          cache_ttl_seconds=args.cache_ttl_seconds,
-        )
-        batch = {}
-        if not (queries := step.queries):
-          logger.error('Please provide one or more queries to run')
-          raise exceptions.GarfExecutorError(
-            'Please provide one or more queries to run'
-          )
-        for query in queries:
-          if isinstance(query, garf_executors.workflow.QueryPath):
-            batch[query.path] = reader_client.read(query.path)
-          else:
-            batch[query.query.title] = query.query.text
-        query_executor.execute_batch(
-          batch, step.context, args.parallel_threshold
-        )
-    sys.exit()
-
-  if not args.query:
-    logger.error('Please provide one or more queries to run')
-    raise exceptions.GarfExecutorError(
-      'Please provide one or more queries to run'
-    )
-  if config_file := args.config:
-    execution_config = config.Config.from_file(config_file)
-    if not (context := execution_config.sources.get(args.source)):
-      raise exceptions.GarfExecutorError(
-        f'No execution context found for source {args.source} in {config_file}'
-      )
-  else:
-    param_types = ['source', 'macro', 'template']
-    outputs = args.output.split(',')
-    extra_parameters = utils.ParamsParser([*param_types, *outputs]).parse(
-      kwargs
-    )
-    source_parameters = extra_parameters.get('source', {})
-    writer_parameters = {}
-    for output in outputs:
-      writer_parameters.update(extra_parameters.get(output))
-
-    context = garf_executors.api_executor.ApiExecutionContext(
-      query_parameters={
-        'macro': extra_parameters.get('macro'),
-        'template': extra_parameters.get('template'),
-      },
-      writer=outputs,
-      writer_parameters=writer_parameters,
-      fetcher_parameters=source_parameters,
-    )
-  query_executor = garf_executors.setup_executor(
-    source=args.source,
-    fetcher_parameters=context.fetcher_parameters,
-    enable_cache=args.enable_cache,
-    cache_ttl_seconds=args.cache_ttl_seconds,
-  )
-  batch = {query: reader_client.read(query) for query in args.query}
-  if args.parallel_queries and len(args.query) > 1:
-    logger.info('Running queries in parallel')
-    batch = {query: reader_client.read(query) for query in args.query}
-    query_executor.execute_batch(batch, context, args.parallel_threshold)
-  else:
-    if len(args.query) > 1:
-      logger.info('Running queries sequentially')
-    for query in args.query:
-      query_executor.execute(
-        query=reader_client.read(query), title=query, context=context
-      )
-  logging.shutdown()
-
-
-if __name__ == '__main__':
-  main()
+warnings.warn(
+  "The 'garf_executors.entrypoints' namespace is deprecated. "
+  "Please use 'garf.executors.entrypoints' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/entrypoints/grcp_server.py

@@ -0,0 +1,25 @@
+# Copyright 2026 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.
+
+
+import warnings
+
+from garf.executors.entrypoints.grpc_server import *
+
+warnings.warn(
+  "The 'garf_executors.entrypoints' namespace is deprecated. "
+  "Please use 'garf.executors.entrypoints' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/entrypoints/server.py

@@ -1,4 +1,4 @@
-# Copyright 2025 Google LLC
+# Copyright 2026 Google LLC
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,107 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""FastAPI endpoint for executing queries."""
 
-from typing import Optional, Union
+import warnings
 
-import fastapi
-import pydantic
-import typer
-import uvicorn
-from garf_io import reader
-from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
-from typing_extensions import Annotated
+from garf.executors.entrypoints.server import *
 
-import garf_executors
-from garf_executors import exceptions
-from garf_executors.entrypoints.tracer import initialize_tracer
-
-initialize_tracer()
-app = fastapi.FastAPI()
-FastAPIInstrumentor.instrument_app(app)
-typer_app = typer.Typer()
-
-
-class ApiExecutorRequest(pydantic.BaseModel):
-  """Request for executing a query.
-
-  Attributes:
-    source: Type of API to interact with.
-    title: Name of the query used as an output for writing.
-    query: Query to execute.
-    query_path: Local or remote path to query.
-    context: Execution context.
-  """
-
-  source: str
-  title: Optional[str] = None
-  query: Optional[str] = None
-  query_path: Optional[Union[str, list[str]]] = None
-  context: garf_executors.api_executor.ApiExecutionContext
-
-  @pydantic.model_validator(mode='after')
-  def check_query_specified(self):
-    if not self.query_path and not self.query:
-      raise exceptions.GarfExecutorError(
-        'Missing one of required parameters: query, query_path'
-      )
-    return self
-
-  def model_post_init(self, __context__) -> None:
-    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]
-
-
-@app.get('/api/version')
-async def version() -> str:
-  return garf_executors.__version__
-
-
-@app.get('/api/fetchers')
-async def get_fetchers() -> list[str]:
-  """Shows all available API sources."""
-  return list(garf_executors.fetchers.find_fetchers())
-
-
-@app.post('/api/execute')
-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])
-
-
-@app.post('/api/execute:batch')
-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)
-
-
-@typer_app.command()
-def main(
-  port: Annotated[int, typer.Option(help='Port to start the server')] = 8000,
-):
-  uvicorn.run(app, port=port)
-
-
-if __name__ == '__main__':
-  typer_app()
+warnings.warn(
+  "The 'garf_executors.entrypoints' namespace is deprecated. "
+  "Please use 'garf.executors.entrypoints' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/entrypoints/tracer.py

@@ -12,46 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
-
-from opentelemetry import trace
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
-  OTLPSpanExporter,
-)
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import (
-  BatchSpanProcessor,
-)
-
-DEFAULT_SERVICE_NAME = 'garf'
 
+import warnings
 
-def initialize_tracer():
-  resource = Resource.create(
-    {'service.name': os.getenv('OTLP_SERVICE_NAME', DEFAULT_SERVICE_NAME)}
-  )
+from garf.executors.entrypoints.tracer import *
 
-  tracer_provider = TracerProvider(resource=resource)
-
-  if otel_endpoint := os.getenv('OTEL_EXPORTER_OTLP_ENDPOINT'):
-    if gcp_project_id := os.getenv('OTEL_EXPORTER_GCP_PROJECT_ID'):
-      try:
-        from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
-      except ImportError as e:
-        raise ImportError(
-          'Please install garf_executors with GCP support '
-          '- `pip install garf_executors[gcp]`'
-        ) from e
-
-      cloud_span_processor = BatchSpanProcessor(
-        CloudTraceSpanExporter(project_id=gcp_project_id)
-      )
-      tracer_provider.add_span_processor(cloud_span_processor)
-    else:
-      otlp_processor = BatchSpanProcessor(
-        OTLPSpanExporter(endpoint=otel_endpoint, insecure=True)
-      )
-      tracer_provider.add_span_processor(otlp_processor)
-
-  trace.set_tracer_provider(tracer_provider)
+warnings.warn(
+  "The 'garf_executors.entrypoints' namespace is deprecated. "
+  "Please use 'garf.executors.entrypoints' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)