omnata-plugin-runtime 0.5.5a127__tar.gz → 0.5.6__tar.gz

{omnata_plugin_runtime-0.5.5a127 → omnata_plugin_runtime-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omnata-plugin-runtime
-Version: 0.5.5a127
+Version: 0.5.6
 Summary: Classes and common runtime components for building and running Omnata Plugins
 Author: James Weakley
 Author-email: james.weakley@omnata.com
@@ -22,6 +22,7 @@ Requires-Dist: numpy (<=1.26.4)
 Requires-Dist: packaging (<=24.1)
 Requires-Dist: pandas (<=2.2.2)
 Requires-Dist: platformdirs (<=3.10.0)
+Requires-Dist: pyarrow (<=16.1.0)
 Requires-Dist: pycparser (<=2.21)
 Requires-Dist: pydantic (>=2,<=2.5.3)
 Requires-Dist: pydantic-core (<=2.14.6)

{omnata_plugin_runtime-0.5.5a127 → omnata_plugin_runtime-0.5.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "omnata-plugin-runtime"
-version = "0.5.5-a127"
+version = "0.5.6"
 description = "Classes and common runtime components for building and running Omnata Plugins"
 authors = ["James Weakley <james.weakley@omnata.com>"]
 readme = "README.md"
@@ -37,6 +37,7 @@ urllib3 = "<=2.2.2" # latest version available on Snowflake Anaconda
 wheel = "<=0.43.0" # latest version available on Snowflake Anaconda
 pyyaml = "<=6.0.1" # latest version available on Snowflake Anaconda
 cffi = "<=1.16.0" # latest version available on Snowflake Anaconda
+pyarrow = "<=16.1.0" # latest version available on Snowflake Anaconda
 
 [tool.poetry.dev-dependencies]
 pytest = "^6.2.4"

{omnata_plugin_runtime-0.5.5a127 → omnata_plugin_runtime-0.5.6}/src/omnata_plugin_runtime/configuration.py

@@ -3,12 +3,14 @@ Omnata Plugin Runtime configuration objects.
 Includes data container classes related to plugin configuration.
 """
 from __future__ import annotations
+import json
 import sys
+import logging
 from typing import Any, List, Dict, Literal, Union, Optional
 from enum import Enum
 
 from abc import ABC
-from pydantic import BaseModel, Field, PrivateAttr, SerializationInfo, field_validator, model_serializer, validator  # pylint: disable=no-name-in-module
+from pydantic import BaseModel, Field, PrivateAttr, SerializationInfo, TypeAdapter, field_validator, model_serializer, validator  # pylint: disable=no-name-in-module
 
 if tuple(sys.version_info[:2]) >= (3, 9):
     # Python 3.9 and above
@@ -17,6 +19,8 @@ else:
     # Python 3.8 and below
     from typing_extensions import Annotated
 
+logger = logging.getLogger(__name__)
+
 
 class MapperType(str, Enum):
     FIELD_MAPPING_SELECTOR = "field_mapping_selector"
@@ -860,3 +864,29 @@ StoredStreamConfiguration.model_rebuild()
 InboundSyncStreamsConfiguration.model_rebuild()
 StoredFieldMappings.model_rebuild()
 OutboundSyncConfigurationParameters.model_rebuild()
+
+
+def get_secrets(oauth_secret_name: Optional[str], other_secrets_name: Optional[str]
+) -> Dict[str, StoredConfigurationValue]:
+    connection_secrets = {}
+    import _snowflake # pylint: disable=import-error, import-outside-toplevel # type: ignore
+    if oauth_secret_name is not None:
+        connection_secrets["access_token"] = StoredConfigurationValue(
+            value=_snowflake.get_oauth_access_token(oauth_secret_name)
+        )
+    if other_secrets_name is not None:
+        try:
+            secret_string_content = _snowflake.get_generic_secret_string(
+                other_secrets_name
+            )
+            if len(secret_string_content) > 2:
+                other_secrets = json.loads(secret_string_content)
+                connection_secrets = {
+                    **connection_secrets,
+                    **TypeAdapter(Dict[str, StoredConfigurationValue]).validate_python(other_secrets),
+                }
+        except Exception as exception:
+            logger.error(f"Error parsing secrets content for secret {other_secrets_name}: {str(exception)}")
+            raise ValueError(f"Error parsing secrets content: {str(exception)}") from exception
+    return connection_secrets
+    

{omnata_plugin_runtime-0.5.5a127 → omnata_plugin_runtime-0.5.6}/src/omnata_plugin_runtime/omnata_plugin.py

@@ -4,7 +4,9 @@ Omnata Plugin Runtime.
 Includes data container classes and defines the contract for a plugin.
 """
 from __future__ import annotations
+from inspect import signature
 import sys
+from types import FunctionType
 from typing import Union
 if tuple(sys.version_info[:2]) >= (3, 9):
     # Python 3.9 and above
@@ -22,6 +24,11 @@ import threading
 import time
 import hashlib
 import requests
+import pkgutil
+import inspect
+import importlib
+import sys
+import os
 from abc import ABC, abstractmethod
 from decimal import Decimal
 from functools import partial, wraps, reduce
@@ -31,7 +38,7 @@ from typing import Any, Callable, Dict, Iterable, List, Literal, Optional, Type,
 import jinja2
 import pandas
 from pydantic_core import to_jsonable_python
-from pydantic import Field, TypeAdapter, root_validator, BaseModel
+from pydantic import Field, TypeAdapter, ValidationError, create_model, root_validator, BaseModel
 from dateutil.parser import parse
 from jinja2 import Environment
 from snowflake.connector.pandas_tools import write_pandas
@@ -65,6 +72,7 @@ from .configuration import (
     StreamConfiguration,
     SubscriptableBaseModel,
     SyncConfigurationParameters,
+    get_secrets
 )
 from .forms import (
     ConnectionMethod,
@@ -119,6 +127,8 @@ class PluginInfo(BaseModel):
         Setting this to 'partner' means that the plugin was developed and distributed by a partner. 
         All other values only carry meaning for Omnata plugins, to indicate which iconography to apply within the application.
     :param str package_source: Whether the plugin is packaged as a function or a stage
+    :param List[UDFDefinition] consumer_udfs: A list of UDFs that the plugin exposes to consumers
+    :param List[UDTFDefinition] consumer_udtfs: A list of UDTFs that the plugin exposes to consumers
     """
 
     manifest: PluginManifest
@@ -131,6 +141,8 @@ class PluginInfo(BaseModel):
     plugin_devkit_version: str = 'unknown'
     tier: str
     package_source: Literal["function", "stage"]
+    consumer_udfs: List[UDFDefinition] = Field(default_factory=list)
+    consumer_udtfs: List[UDTFDefinition] = Field(default_factory=list)
 
 
 def jinja_filter(func):
@@ -2220,3 +2232,304 @@ def get_nested_value(nested_dict:Dict, keys:List[str]):
     if isinstance(keys, str):
         keys = [keys]
     return reduce(lambda d, key: d.get(key) if isinstance(d, dict) else None, keys, nested_dict)
+
+
+class SnowflakeFunctionParameter(BaseModel):
+    """
+    Represents a parameter for a Snowflake UDF or UDTF
+    """
+    name: str
+    description: str
+    data_type: str
+    default_value_clause: Optional[str] = None
+
+    def __str__(self):
+        if self.default_value_clause:
+            return f"{self.name} {self.data_type} default {self.default_value_clause}"
+        return f"{self.name} {self.data_type}"
+
+class SnowflakeUDTFResultColumn(BaseModel):
+    """
+    Represents a result column for a Snowflake UDTF
+    """
+    name: str
+    data_type: str
+    def __str__(self):
+        return f"{self.name} {self.data_type}"
+
+class UDTFDefinition(BaseModel):
+    """
+    The information needed by the plugin uploader to put a Python UDTF definition into the setup script.
+    Do not use this class directly in plugins, instead use the omnata_udtf decorator.
+    """
+    name: str = Field(..., title="The name of the UDTF")
+    language: Literal['python','java'] = Field(..., title="The language of the UDF")
+    runtime_version: str = Field(..., title="The runtime version of the UDF (language dependent)")
+    description: str = Field(..., title="A description of the UDTF")
+    params: List[SnowflakeFunctionParameter] = Field(..., title="The parameters of the UDTF")
+    result_columns: List[SnowflakeUDTFResultColumn] = Field(..., title="The result columns of the UDTF")
+    handler: str = Field(..., title="The handler class/function for the UDTF")
+    expose_to_consumer: bool = Field(..., title="Whether the UDTF should be exposed to consumers")
+    imports: Optional[List[str]] = Field(None, title="A list of imports required by the UDF")
+    packages: Optional[List[str]] = Field(None, title="A list of packages required by the UDTF")
+
+    def __str__(self):
+        param_str = ', '.join([str(param) for param in self.params])
+        table_result_columns = ', '.join([f"{col.name} {col.data_type}" for col in self.result_columns])
+        packages_str = ', '.join([f"'{p}'" for p in self.packages])
+        imports_str = ', '.join([f"'{i}'" for i in self.imports])
+        return f"""CREATE OR REPLACE FUNCTION UDFS.{self.name}({param_str})
+RETURNS TABLE({table_result_columns})
+LANGUAGE {self.language.upper()}
+RUNTIME_VERSION={self.runtime_version}
+COMMENT = $${self.description}$$
+PACKAGES = ({packages_str})
+IMPORTS = ({imports_str})
+HANDLER='{self.handler}';
+"""
+
+class UDFDefinition(BaseModel):
+    """
+    The information needed by the plugin uploader to put a Python UDF definition into the setup script.
+    Do not use this class directly in plugins, instead use the omnata_udf decorator.
+    """
+    name: str = Field(..., title="The name of the UDF")
+    language: Literal['python','java'] = Field(..., title="The language of the UDF")
+    runtime_version: str = Field(..., title="The runtime version of the UDF (language dependent)")
+    description: str = Field(..., title="A description of the UDF")
+    params: List[SnowflakeFunctionParameter] = Field(..., title="The parameters of the UDF")
+    result_data_type: str = Field(..., title="The data type returned by the UDF")
+    handler: str = Field(..., title="The handler class/function for the UDF")
+    expose_to_consumer: bool = Field(..., title="Whether the UDF should be exposed to consumers")
+    imports: Optional[List[str]] = Field(None, title="A list of imports required by the UDF")
+    packages: Optional[List[str]] = Field(None, title="A list of packages required by the UDF")
+
+    def __str__(self):
+        param_str = ', '.join([str(param) for param in self.params])
+        packages_str = ', '.join([f"'{p}'" for p in self.packages])
+        imports_str = ', '.join([f"'{i}'" for i in self.imports])
+        return f"""CREATE OR REPLACE FUNCTION UDFS.{self.name}({param_str})
+RETURNS {self.result_data_type}
+LANGUAGE {self.language.upper()}
+RUNTIME_VERSION={self.runtime_version}
+COMMENT = $${self.description}$$
+PACKAGES = ({packages_str})
+IMPORTS = ({imports_str})
+HANDLER='{self.handler}';
+"""
+
+def omnata_udtf(
+        name:str,
+        description: str,
+        params: List[SnowflakeFunctionParameter],
+        result_columns: List[SnowflakeUDTFResultColumn],
+        expose_to_consumer: bool):
+    """
+    A decorator for a class which should create a UDTF in the UDFS schema of the native app
+    """
+    def class_decorator(cls):
+        # Get the original 'process' method from the class
+        if not hasattr(cls, 'process'):
+            raise ValueError("The class must have a 'process' method.")
+        original_process = getattr(cls, 'process')
+        sig = signature(original_process)
+        function_params = sig.parameters
+        if len(function_params) < 1:
+            raise ValueError("The 'process' function must have at least one parameter.")
+        
+        first_param_name = list(function_params.keys())[0]
+        if first_param_name != 'self':
+            raise ValueError(f"The first argument for the 'process' function should be 'self', instead it was '{first_param_name}'.")
+
+        cls._is_omnata_udtf = True
+        cls._omnata_udtf_name = name
+        cls._omnata_udtf_description = description
+        cls._omnata_udtf_params = params
+        cls._omnata_udtf_result_columns = result_columns
+        cls._omnata_udtf_expose_to_consumer = expose_to_consumer
+
+        if not expose_to_consumer:
+            # If not exposing to the consumer, there are no further requirements
+            return cls
+        
+        if len(function_params) < 2:
+            raise ValueError("When exposing the udtf to consumers, the 'process' function must have the self parameter, plus at least the mandatory 'connection_parameters' parameter.")
+        second_param_name = list(function_params.keys())[1]
+        if second_param_name != 'connection_parameters':
+            raise ValueError(f"The second argument should be 'connection_parameters', instead it was {second_param_name}.")
+        if function_params[second_param_name].annotation != ConnectionConfigurationParameters:
+            raise ValueError(f"The second argument must be a ConnectionConfigurationParameters, instead it was a {function_params[second_param_name].annotation}.")
+
+        if params[0].name.upper() != 'CONNECTION_PARAMETERS':
+            params_new = [SnowflakeFunctionParameter(
+                                    name='CONNECTION_PARAMETERS',
+                                    data_type='OBJECT',
+                                    description='The connection object, obtained from calling PLUGIN.PLUGIN_CONNECTION.')] + params
+            cls._omnata_udtf_params = params_new
+        if len(params_new) != len(function_params) -1:
+            raise ValueError(f"You must document all the parameters of the 'process' function in the @omnata_udtf decorator in the same order ('connection_parameters' will be included automatically).")
+
+        @wraps(original_process)
+        def wrapped_process(self, connection_parameter_arg, *args, **kwargs):
+            if connection_parameter_arg is None:
+                raise ValueError("Connection not found")           
+            
+            # convert the connection parameters dictionary to a ConnectionConfigurationParameters object which includes the real secrets
+            if 'other_secrets_name' in connection_parameter_arg:
+                # this is the new way, where the sync engine only passes the name of the secret
+                oauth_secrets_name = None
+                if 'oauth_secret_name' in connection_parameter_arg:
+                    oauth_secrets_name = connection_parameter_arg['oauth_secret_name']
+                    del connection_parameter_arg['oauth_secret_name']
+                result = get_secrets(oauth_secrets_name,connection_parameter_arg['other_secrets_name'])
+                connection_parameter_arg['connection_secrets'] = result
+                del connection_parameter_arg['other_secrets_name']
+            
+            parameters = ConnectionConfigurationParameters.model_validate(connection_parameter_arg)
+
+            # Pass the validated arguments to the function
+            return original_process(self, parameters, *args, **kwargs)
+        # Replace the original 'process' method with the wrapped version
+        setattr(cls, 'process', wrapped_process)
+        return cls
+    
+    return class_decorator
+
+def find_udtf_classes(path:str = '.') -> List[UDTFDefinition]:
+    """
+    Finds all classes in the specified directory which have the 'omnata_udtf' decorator applied
+    """
+    # Get the directory's absolute path
+    current_dir = os.path.abspath(path)
+
+    # List to hold the classes that match the attribute
+    matching_classes = []
+
+    # Iterate over all modules in the current directory
+    for _, module_name, _ in pkgutil.iter_modules([current_dir]):
+        # Import the module
+        module = importlib.import_module(module_name)
+
+        # Iterate over all members of the module
+        for name, obj in inspect.getmembers(module, inspect.isclass):
+            # Check if the class has the specified attribute
+            if hasattr(obj, '_is_omnata_udtf'):
+                matching_classes.append(UDTFDefinition(
+                    name=obj._omnata_udtf_name,
+                    language='python',
+                    runtime_version='3.10',
+                    imports=['/app.zip'],
+                    description=obj._omnata_udtf_description,
+                    params=obj._omnata_udtf_params,
+                    result_columns=obj._omnata_udtf_result_columns,
+                    expose_to_consumer=obj._omnata_udtf_expose_to_consumer,
+                    handler=obj.__module__+'.'+obj.__name__
+                ))
+            elif isinstance(obj, UDTFDefinition) and cast(UDTFDefinition,obj).language == 'java':
+                matching_classes.append(obj)
+            
+    return matching_classes
+
+
+def omnata_udf(
+        name: str,
+        description: str,
+        params: List[SnowflakeFunctionParameter],
+        result_data_type: str,
+        expose_to_consumer: bool):
+    """
+    A decorator for a function which will be created in the native application.
+    """
+    def decorator(func):
+        sig = signature(func)
+        function_params = sig.parameters
+
+        if not expose_to_consumer:
+            # If not exposing to the consumer, there are no further requirements
+            func._is_omnata_udf = True
+            func._omnata_udf_name = name
+            func._omnata_udf_description = description
+            func._omnata_udf_params = params
+            func._omnata_udf_result_data_type = result_data_type
+            func._omnata_udf_expose_to_consumer = expose_to_consumer
+            return func
+        
+        if len(function_params) == 0:
+            raise ValueError("The function must have at least one parameter.")
+        # Ensure the first argument is mandatory and positional
+        first_param_name = list(function_params.keys())[0]
+        if first_param_name != 'connection_parameters':
+            raise ValueError(f"The first argument should be 'connection_parameters', instead it was '{first_param_name}'.")
+        if function_params[first_param_name].annotation != ConnectionConfigurationParameters:
+            raise ValueError(f"The first argument must be a ConnectionConfigurationParameters, instead it was a {function_params[first_param_name].annotation}.")
+        if params[0].name.upper() != 'CONNECTION_PARAMETERS':
+            params_new = [SnowflakeFunctionParameter(
+                                    name='CONNECTION_PARAMETERS',
+                                    data_type='OBJECT',
+                                    description='The connection object, obtained from calling PLUGIN.PLUGIN_CONNECTION.')] + params
+            func._omnata_udf_params = params_new
+        if len(params_new) != len(function_params):
+            raise ValueError(f"You must document all the parameters of the function in the @omnata_udf decorator in the same order ('connection_parameters' will be included automatically).")
+
+        @wraps(func)
+        def wrapper(connection_parameter_arg, *args, **kwargs):
+            # convert the connection parameters dictionary to a ConnectionConfigurationParameters object which includes the real secrets
+            if 'other_secrets_name' in connection_parameter_arg:
+                # this is the new way, where the sync engine only passes the name of the secret
+                oauth_secrets_name = None
+                if 'oauth_secret_name' in connection_parameter_arg:
+                    oauth_secrets_name = connection_parameter_arg['oauth_secret_name']
+                    del connection_parameter_arg['oauth_secret_name']
+                result = get_secrets(oauth_secrets_name,connection_parameter_arg['other_secrets_name'])
+                connection_parameter_arg['connection_secrets'] = result
+                del connection_parameter_arg['other_secrets_name']
+                
+            parameters = ConnectionConfigurationParameters.model_validate(connection_parameter_arg)
+
+            # Pass the validated arguments to the function
+            return func(parameters, *args, **kwargs)
+        
+        wrapper._is_omnata_udf = True
+        wrapper._omnata_udf_name = name
+        wrapper._omnata_udf_description = description
+        wrapper._omnata_udf_result_data_type = result_data_type
+        wrapper._omnata_udf_expose_to_consumer = expose_to_consumer
+        return wrapper
+    
+    return decorator
+
+def find_udf_functions(path:str = '.') -> List[UDFDefinition]:
+    """
+    Finds all functions in the specified directory which have the 'omnata_udf' decorator applied
+    """
+    # Get the current directory's absolute path
+    current_dir = os.path.abspath(path)
+
+    # List to hold the classes that match the attribute
+    matching_classes = []
+
+    # Iterate over all modules in the current directory
+    for _, module_name, _ in pkgutil.iter_modules([current_dir]):
+        # Import the module
+        module = importlib.import_module(module_name)
+
+        # Iterate over all members of the module
+        for name, obj in inspect.getmembers(module, inspect.isfunction):
+            # Check if the class has the specified attribute
+            if hasattr(obj, '_is_omnata_udf'):
+                matching_classes.append(UDFDefinition(
+                    name=obj._omnata_udf_name,
+                    language='python',
+                    runtime_version='3.10',
+                    imports=['/app.zip'],
+                    description=obj._omnata_udf_description,
+                    params=obj._omnata_udf_params,
+                    result_data_type=obj._omnata_udf_result_data_type,
+                    expose_to_consumer=obj._omnata_udf_expose_to_consumer,
+                    packages=[],
+                    handler=obj.__module__+'.'+obj.__name__
+                ))
+            elif isinstance(obj, UDFDefinition) and cast(UDFDefinition,obj).language == 'java':
+                matching_classes.append(obj)
+
+    return matching_classes

{omnata_plugin_runtime-0.5.5a127 → omnata_plugin_runtime-0.5.6}/src/omnata_plugin_runtime/plugin_entrypoints.py

@@ -20,6 +20,7 @@ from .configuration import (
     OutboundSyncStrategy,
     StoredConfigurationValue,
     StoredMappingValue,
+    get_secrets
 )
 from .forms import ConnectionMethod, FormInputField, FormOption
 from .logging import OmnataPluginLogHandler
@@ -71,7 +72,7 @@ class PluginEntrypoint:
     def sync(self, sync_request: Dict):
         logger.info("Entered sync method")
         request = TypeAdapter(SyncRequestPayload).validate_python(sync_request)
-        connection_secrets = self.get_secrets(
+        connection_secrets = get_secrets(
             request.oauth_secret_name, request.other_secrets_name
         )
         omnata_log_handler = OmnataPluginLogHandler(
@@ -270,7 +271,7 @@ class PluginEntrypoint:
         sync_strategy = normalise_nulls(sync_strategy)
         oauth_secret_name = normalise_nulls(oauth_secret_name)
         other_secrets_name = normalise_nulls(other_secrets_name)
-        connection_secrets = self.get_secrets(oauth_secret_name, other_secrets_name)
+        connection_secrets = get_secrets(oauth_secret_name, other_secrets_name)
         connection_parameters = TypeAdapter(
             Dict[str, StoredConfigurationValue]).validate_python(connection_parameters)
         sync_parameters = TypeAdapter(
@@ -324,7 +325,7 @@ class PluginEntrypoint:
         logger.info("Entered list_streams method")
         oauth_secret_name = normalise_nulls(oauth_secret_name)
         other_secrets_name = normalise_nulls(other_secrets_name)
-        connection_secrets = self.get_secrets(oauth_secret_name, other_secrets_name)
+        connection_secrets = get_secrets(oauth_secret_name, other_secrets_name)
         connection_parameters = TypeAdapter(
             Dict[str, StoredConfigurationValue]).validate_python(connection_parameters)
         sync_parameters = TypeAdapter(
@@ -411,31 +412,6 @@ class PluginEntrypoint:
                     raise e
         return [e.model_dump() for e in events]
 
-    def get_secrets(
-        self, oauth_secret_name: Optional[str], other_secrets_name: Optional[str]
-    ) -> Dict[str, StoredConfigurationValue]:
-        connection_secrets = {}
-        import _snowflake # pylint: disable=import-error, import-outside-toplevel # type: ignore
-        if oauth_secret_name is not None:
-            connection_secrets["access_token"] = StoredConfigurationValue(
-                value=_snowflake.get_oauth_access_token(oauth_secret_name)
-            )
-        if other_secrets_name is not None:
-            try:
-                secret_string_content = _snowflake.get_generic_secret_string(
-                    other_secrets_name
-                )
-                if len(secret_string_content) > 2:
-                    other_secrets = json.loads(secret_string_content)
-                    connection_secrets = {
-                        **connection_secrets,
-                        **TypeAdapter(Dict[str, StoredConfigurationValue]).validate_python(other_secrets),
-                    }
-            except Exception as exception:
-                logger.error(f"Error parsing secrets content for secret {other_secrets_name}: {str(exception)}")
-                raise ValueError(f"Error parsing secrets content: {str(exception)}") from exception
-        return connection_secrets
-    
     def ngrok_post_tunnel_fields(
         self,
         connection_method: str,
@@ -447,7 +423,7 @@ class PluginEntrypoint:
         logger.info("Entered ngrok_post_tunnel_fields method")
         oauth_secret_name = normalise_nulls(oauth_secret_name)
         other_secrets_name = normalise_nulls(other_secrets_name)
-        connection_secrets = self.get_secrets(oauth_secret_name, other_secrets_name)
+        connection_secrets = get_secrets(oauth_secret_name, other_secrets_name)
         connection_parameters = TypeAdapter(
             Dict[str, StoredConfigurationValue]).validate_python(connection_parameters)
         parameters = ConnectionConfigurationParameters(
@@ -493,7 +469,7 @@ class PluginEntrypoint:
     ):
         logger.info("Entered connect method")
         logger.info(f"Connection parameters: {connection_parameters}")
-        connection_secrets = self.get_secrets(oauth_secret_name, other_secrets_name)
+        connection_secrets = get_secrets(oauth_secret_name, other_secrets_name)
 
         from omnata_plugin_runtime.omnata_plugin import (
             ConnectionConfigurationParameters,
@@ -540,7 +516,7 @@ class PluginEntrypoint:
                     oauth_secret_name: Optional[str],
                     other_secrets_name: Optional[str]):
         logger.info("Entered api_limits method")
-        connection_secrets = self.get_secrets(oauth_secret_name, other_secrets_name)
+        connection_secrets = get_secrets(oauth_secret_name, other_secrets_name)
         from omnata_plugin_runtime.omnata_plugin import (
             ConnectionConfigurationParameters,
         )