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

garf_executors/entrypoints/utils.py

@@ -1,4 +1,4 @@
-# Copyright 2022 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,130 +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 various helpers for executing Garf as CLI tool."""
 
-from __future__ import annotations
 
-import enum
-import logging
-import sys
-from collections.abc import Sequence
-from typing import Any
+import warnings
 
-from rich import logging as rich_logging
+from garf.executors.entrypoints.utils import *
 
-
-class ParamsParser:
-  def __init__(self, identifiers: Sequence[str]) -> None:
-    self.identifiers = identifiers
-
-  def parse(self, params: Sequence) -> dict[str, dict | None]:
-    return {
-      identifier: self._parse_params(identifier, params)
-      for identifier in self.identifiers
-    }
-
-  def _parse_params(self, identifier: str, params: Sequence[Any]) -> dict:
-    parsed_params = {}
-    if params:
-      raw_params = [param.split('=', maxsplit=1) for param in params]
-      for param in raw_params:
-        param_pair = self._identify_param_pair(identifier, param)
-        if param_pair:
-          parsed_params.update(param_pair)
-    return parsed_params
-
-  def _identify_param_pair(
-    self, identifier: str, param: Sequence[str]
-  ) -> dict[str, Any] | None:
-    key = param[0]
-    if not identifier or identifier not in key:
-      return None
-    provided_identifier, *keys = key.split('.')
-    if not keys:
-      return None
-    if len(keys) > 1:
-      raise GarfParamsException(
-        f'{key} is invalid format,'
-        f'`--{identifier}.key=value` or `--{identifier}.key` '
-        'are the correct formats'
-      )
-    provided_identifier = provided_identifier.replace('--', '')
-    if provided_identifier not in self.identifiers:
-      supported_arguments = ', '.join(self.identifiers)
-      raise GarfParamsException(
-        f'CLI argument {provided_identifier} is not supported'
-        f', supported arguments {supported_arguments}'
-      )
-    if provided_identifier != identifier:
-      return None
-    key = keys[0].replace('-', '_')
-    if not key:
-      raise GarfParamsException(
-        f'{identifier} {key} is invalid,'
-        f'`--{identifier}.key=value` or `--{identifier}.key` '
-        'are the correct formats'
-      )
-    if len(param) == 2:
-      return {key: param[1]}
-    if len(param) == 1:
-      return {key: True}
-    raise GarfParamsException(
-      f'{identifier} {key} is invalid,'
-      f'`--{identifier}.key=value` or `--{identifier}.key` '
-      'are the correct formats'
-    )
-
-
-class GarfParamsException(Exception):
-  """Defines exception for incorrect parameters."""
-
-
-class LoggerEnum(str, enum.Enum):
-  local = 'local'
-  rich = 'rich'
-  gcloud = 'gcloud'
-
-
-def init_logging(
-  loglevel: str = 'INFO',
-  logger_type: str | LoggerEnum = 'local',
-  name: str = __name__,
-) -> logging.Logger:
-  loglevel = getattr(logging, loglevel)
-  if logger_type == 'rich':
-    logging.basicConfig(
-      format='%(message)s',
-      level=loglevel,
-      datefmt='%Y-%m-%d %H:%M:%S',
-      handlers=[
-        rich_logging.RichHandler(rich_tracebacks=True),
-      ],
-    )
-  elif logger_type == 'gcloud':
-    try:
-      import google.cloud.logging as glogging
-    except ImportError as e:
-      raise ImportError(
-        'Please install garf-executors with Cloud logging support - '
-        '`pip install garf-executors[bq]`'
-      ) from e
-
-    client = glogging.Client()
-    handler = glogging.handlers.CloudLoggingHandler(client, name=name)
-    handler.close()
-    glogging.handlers.setup_logging(handler, log_level=loglevel)
-    logging.basicConfig(
-      level=loglevel,
-      handlers=[handler],
-    )
-  else:
-    logging.basicConfig(
-      format='[%(asctime)s][%(name)s][%(levelname)s] %(message)s',
-      stream=sys.stdout,
-      level=loglevel,
-      datefmt='%Y-%m-%d %H:%M:%S',
-    )
-  logging.getLogger('smart_open.smart_open_lib').setLevel(logging.WARNING)
-  logging.getLogger('urllib3.connectionpool').setLevel(logging.WARNING)
-  return logging.getLogger(name)
+warnings.warn(
+  "The 'garf_executors.entrypoints' namespace is deprecated. "
+  "Please use 'garf.executors.entrypoints' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/exceptions.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.
@@ -13,5 +13,13 @@
 # limitations under the License.
 
 
-class GarfExecutorError(Exception):
-  """Base class for garf executor exceptions."""
+import warnings
+
+from garf.executors.exceptions import *
+
+warnings.warn(
+  "The 'garf_executors' namespace is deprecated. "
+  "Please use 'garf.executors' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/execution_context.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,105 +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
 
-"""Captures parameters for fetching data from APIs."""
+import warnings
 
-from __future__ import annotations
+from garf.executors.execution_context import *
 
-import os
-import pathlib
-
-import pydantic
-import smart_open
-import yaml
-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. Can be a single writer string or list of writers.
-    writer_parameters: Optional parameters to setup writer.
-  """
-
-  query_parameters: query_editor.GarfQueryParameters | None = pydantic.Field(
-    default_factory=dict
-  )
-  fetcher_parameters: dict[str, str | bool | int | list[str | int]] | None = (
-    pydantic.Field(default_factory=dict)
-  )
-  writer: str | list[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 = {}
-    if not self.query_parameters:
-      self.query_parameters = query_editor.GarfQueryParameters()
-
-  @classmethod
-  def from_file(
-    cls, path: str | pathlib.Path | os.PathLike[str]
-  ) -> ExecutionContext:
-    """Builds context from local or remote yaml file."""
-    with smart_open.open(path, 'r', encoding='utf-8') as f:
-      data = yaml.safe_load(f)
-    return ExecutionContext(**data)
-
-  def save(self, path: str | pathlib.Path | os.PathLike[str]) -> str:
-    """Saves context to local or remote yaml file."""
-    with smart_open.open(path, 'w', encoding='utf-8') as f:
-      yaml.dump(self.model_dump(), f, encoding='utf-8')
-    return f'ExecutionContext is saved to {str(path)}'
-
-  @property
-  def writer_client(self) -> abs_writer.AbsWriter:
-    """Returns single writer client."""
-    if isinstance(self.writer, list) and len(self.writer) > 0:
-      writer_type = self.writer[0]
-    else:
-      writer_type = self.writer
-
-    writer_params = self.writer_parameters or {}
-
-    if not writer_type:
-      raise ValueError('No writer specified')
-
-    writer_client = writer.create_writer(writer_type, **writer_params)
-    if writer_type == 'bq':
-      _ = writer_client.create_or_get_dataset()
-    if writer_type == 'sheet':
-      writer_client.init_client()
-    return writer_client
-
-  @property
-  def writer_clients(self) -> list[abs_writer.AbsWriter]:
-    """Returns list of writer clients."""
-    if not self.writer:
-      return []
-
-    # Convert single writer to list for uniform processing
-    writers_to_use = (
-      self.writer if isinstance(self.writer, list) else [self.writer]
-    )
-    writer_params = self.writer_parameters or {}
-
-    clients = []
-    for writer_type in writers_to_use:
-      writer_client = writer.create_writer(writer_type, **writer_params)
-      if writer_type == 'bq':
-        _ = writer_client.create_or_get_dataset()
-      if writer_type == 'sheet':
-        writer_client.init_client()
-      clients.append(writer_client)
-    return clients
+warnings.warn(
+  "The 'garf_executors' namespace is deprecated. "
+  "Please use 'garf.executors' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/executor.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,113 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Defines common functionality between executors."""
 
-import asyncio
-import inspect
-from typing import Optional
+import warnings
 
-from garf_core import report_fetcher
-from opentelemetry import trace
+from garf.executors.executor import *
 
-from garf_executors import execution_context
-from garf_executors.telemetry import tracer
-
-
-class Executor:
-  """Defines common functionality between executors."""
-
-  def __init__(
-    self,
-    preprocessors: Optional[dict[str, report_fetcher.Processor]] = None,
-    postprocessors: Optional[dict[str, report_fetcher.Processor]] = None,
-  ) -> None:
-    self.preprocessors = preprocessors or {}
-    self.postprocessors = postprocessors or {}
-
-  @tracer.start_as_current_span('api.execute_batch')
-  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.
-
-    If an executor has any pre/post processors, executes them first while
-    modifying the 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.
-    """
-    span = trace.get_current_span()
-    span.set_attribute('api.parallel_threshold', parallel_threshold)
-    _handle_processors(processors=self.preprocessors, context=context)
-    results = asyncio.run(
-      self._run(
-        batch=batch, context=context, parallel_threshold=parallel_threshold
-      )
-    )
-    _handle_processors(processors=self.postprocessors, context=context)
-    return results
-
-  def add_preprocessor(
-    self, preprocessors: dict[str, report_fetcher.Processor]
-  ) -> None:
-    self.preprocessors.update(preprocessors)
-
-  async def aexecute(
-    self,
-    query: str,
-    title: str,
-    context: execution_context.ExecutionContext,
-  ) -> str:
-    """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.
-    """
-    return await asyncio.to_thread(self.execute, query, title, context)
-
-  async def _run(
-    self,
-    batch: dict[str, str],
-    context: execution_context.ExecutionContext,
-    parallel_threshold: int,
-  ):
-    semaphore = asyncio.Semaphore(value=parallel_threshold)
-
-    async def run_with_semaphore(fn):
-      async with semaphore:
-        return await fn
-
-    tasks = [
-      self.aexecute(query=query, title=title, context=context)
-      for title, query in batch.items()
-    ]
-    return await asyncio.gather(*(run_with_semaphore(task) for task in tasks))
-
-
-def _handle_processors(
-  processors: dict[str, report_fetcher.Processor],
-  context: execution_context.ExecutionContext,
-) -> None:
-  for k, processor in processors.items():
-    processor_signature = list(inspect.signature(processor).parameters.keys())
-    if k in context.fetcher_parameters:
-      processor_parameters = {
-        k: v
-        for k, v in context.fetcher_parameters.items()
-        if k in processor_signature
-      }
-      context.fetcher_parameters[k] = processor(**processor_parameters)
+warnings.warn(
+  "The 'garf_executors' namespace is deprecated. "
+  "Please use 'garf.executors' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/fetchers.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,68 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import inspect
-import logging
-import sys
-from importlib.metadata import entry_points
 
-from garf_core import report_fetcher
+import warnings
 
-from garf_executors.telemetry import tracer
+from garf.executors.fetchers import *
 
-logger = logging.getLogger(name='garf_executors.fetchers')
-
-
-@tracer.start_as_current_span('find_fetchers')
-def find_fetchers() -> set[str]:
-  """Identifiers all available report fetchers."""
-  if entrypoints := _get_entrypoints('garf'):
-    return {fetcher.name for fetcher in entrypoints}
-  return set()
-
-
-@tracer.start_as_current_span('get_report_fetcher')
-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)
-  for fetcher in _get_entrypoints('garf'):
-    if fetcher.name == source:
-      try:
-        with tracer.start_as_current_span('load_fetcher_module') as span:
-          fetcher_module = fetcher.load()
-          span.set_attribute('loaded_module', fetcher_module.__name__)
-        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 as e:
-        raise report_fetcher.ApiReportFetcherError(
-          f'Failed to load fetcher for source {source}, reason: {e}'
-        )
-  raise report_fetcher.ApiReportFetcherError(
-    f'No fetcher available for the source "{source}"'
-  )
-
-
-def _get_entrypoints(group='garf'):
-  if sys.version_info.major == 3 and sys.version_info.minor == 9:
-    try:
-      fetchers = entry_points()[group]
-    except KeyError:
-      fetchers = []
-  else:
-    fetchers = entry_points(group=group)
-  return fetchers
+warnings.warn(
+  "The 'garf_executors' namespace is deprecated. "
+  "Please use 'garf.executors' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/sql_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,131 +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.
-"""Defines mechanism for executing queries via SqlAlchemy."""
 
-from __future__ import annotations
 
-try:
-  import sqlalchemy
-except ImportError as e:
-  raise ImportError(
-    'Please install garf-executors with sqlalchemy support '
-    '- `pip install garf-executors[sqlalchemy]`'
-  ) from e
+import warnings
 
-import logging
-import re
-import uuid
+from garf.executors.sql_executor import *
 
-import pandas as pd
-from garf_core import query_editor, report
-from opentelemetry import trace
-
-from garf_executors import exceptions, execution_context, executor
-from garf_executors.telemetry import tracer
-
-logger = logging.getLogger(__name__)
-
-
-class SqlAlchemyQueryExecutorError(exceptions.GarfExecutorError):
-  """Error when SqlAlchemyQueryExecutor fails to run query."""
-
-
-class SqlAlchemyQueryExecutor(
-  executor.Executor, query_editor.TemplateProcessorMixin
-):
-  """Handles query execution via SqlAlchemy.
-
-  Attributes:
-      engine: Initialized Engine object to operated on a given database.
-  """
-
-  def __init__(self, engine: sqlalchemy.engine.base.Engine) -> None:
-    """Initializes executor with a given engine.
-
-    Args:
-        engine: Initialized Engine object to operated on a given database.
-    """
-    self.engine = engine
-    super().__init__()
-
-  @classmethod
-  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)
-
-  @tracer.start_as_current_span('sql.execute')
-  def execute(
-    self,
-    query: str,
-    title: str,
-    context: execution_context.ExecutionContext = (
-      execution_context.ExecutionContext()
-    ),
-  ) -> report.GarfReport:
-    """Executes query in a given database via SqlAlchemy.
-
-    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)
-    with self.engine.begin() as conn:
-      if re.findall(r'(create|update) ', query_text.lower()):
-        try:
-          conn.connection.executescript(query_text)
-          results = report.GarfReport()
-        except Exception as e:
-          raise SqlAlchemyQueryExecutorError(
-            f'Failed to execute query {title}: Reason: {e}'
-          ) from e
-      else:
-        temp_table_name = f'temp_{uuid.uuid4().hex}'
-        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)
-          )
-        except Exception as e:
-          raise SqlAlchemyQueryExecutorError(
-            f'Failed to execute query {title}: Reason: {e}'
-          ) from e
-        finally:
-          conn.connection.execute(f'DROP TABLE {temp_table_name}')
-      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)
-          logger.info('%s executed successfully', title)
-          # Return the last writer's result for backward compatibility
-          return writing_results[-1] if writing_results else None
-      span.set_attribute('execute.num_results', len(results))
-      return results
+warnings.warn(
+  "The 'garf_executors' namespace is deprecated. "
+  "Please use 'garf.executors' instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)

garf_executors/telemetry.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,9 +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
-from opentelemetry import trace
 
-tracer = trace.get_tracer(
-  instrumenting_module_name='garf_executors',
+import warnings
+
+from garf.executors.telemetry import *
+
+warnings.warn(
+  "The 'garf_executors' namespace is deprecated. "
+  "Please use 'garf.executors' instead.",
+  DeprecationWarning,
+  stacklevel=2,
 )