omnata-plugin-runtime 0.5.7a129__tar.gz → 0.5.7a131__tar.gz

{omnata_plugin_runtime-0.5.7a129 → omnata_plugin_runtime-0.5.7a131}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omnata-plugin-runtime
-Version: 0.5.7a129
+Version: 0.5.7a131
 Summary: Classes and common runtime components for building and running Omnata Plugins
 Author: James Weakley
 Author-email: james.weakley@omnata.com

{omnata_plugin_runtime-0.5.7a129 → omnata_plugin_runtime-0.5.7a131}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "omnata-plugin-runtime"
-version = "0.5.7-a129"
+version = "0.5.7-a131"
 description = "Classes and common runtime components for building and running Omnata Plugins"
 authors = ["James Weakley <james.weakley@omnata.com>"]
 readme = "README.md"

{omnata_plugin_runtime-0.5.7a129 → omnata_plugin_runtime-0.5.7a131}/src/omnata_plugin_runtime/omnata_plugin.py

@@ -23,6 +23,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
@@ -2226,6 +2231,7 @@ def get_nested_value(nested_dict:Dict, keys:List[str]):
 def consumer_udtf(param_docs: Dict[str, Dict[str, Any]]):
     def class_decorator(cls):
         # Get the original 'process' method from the class
+        cls._is_omnata_consumer_udtf = True
         original_process = getattr(cls, 'process')
         sig = signature(original_process)
         params = sig.parameters
@@ -2241,7 +2247,7 @@ def consumer_udtf(param_docs: Dict[str, Dict[str, Any]]):
         fields = {
             name: (param.annotation, param_docs.get(name, {}).get("default", param.default))
             for name, param in params.items()
-            if name != 'self' and name != 'mandatory_arg'
+            if name != 'cls' and name != 'connection_parameters'
         }
 
         DynamicModel = create_model('DynamicModel', **fields)
@@ -2292,3 +2298,83 @@ def consumer_udtf(param_docs: Dict[str, Dict[str, Any]]):
     
     return class_decorator
 
+def find_classes_with_attribute(attribute_name: str,path:str = '.'):
+    # 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, attribute_name):
+                matching_classes.append(obj)
+
+
+def consumer_udf(param_docs: Dict[str, Dict[str, Any]]):
+    def decorator(func):
+        sig = signature(func)
+        params = sig.parameters
+
+        # Ensure the first argument is mandatory and positional
+        if list(params.keys())[0] != 'connection_parameters':
+            raise ValueError("The first argument should be 'connection_parameters'.")
+
+        # Create a Pydantic model based on the function signature and the provided documentation
+        fields = {
+            name: (param.annotation, param_docs.get(name, {}).get("default", param.default))
+            for name, param in params.items()
+            if name != 'connection_parameters'
+        }
+
+        DynamicModel = create_model('DynamicModel', **fields)
+
+        # Attach the documentation to the function
+        func.__doc__ = func.__doc__ or ""
+        func.__doc__ += "\n\nArgs:\n"
+        for name, param in params.items():
+            doc = param_docs.get(name, {})
+            func.__doc__ += f"    {name} ({param.annotation.__name__}): {doc.get('description', 'No description provided.')}\n"
+
+        @wraps(func)
+        def wrapper(self, connection_parameters, *args, **kwargs):
+            if connection_parameters is None:
+                raise ValueError("Connection not found")
+            
+            if not isinstance(connection_parameters, Dict):
+                raise ValueError("The first argument must be an object, the result of calling PLUGIN_CONNECTION.")
+
+            try:
+                # Validate the arguments using the dynamic Pydantic model
+                validated_args = DynamicModel(**kwargs)
+            except ValidationError as e:
+                raise ValueError(f"Argument validation error: {e}")
+            
+            # convert the connection parameters dictionary to a ConnectionConfigurationParameters object which includes the real secrets
+            if 'other_secrets_name' in connection_parameters:
+                # 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_parameters:
+                    oauth_secrets_name = connection_parameters['oauth_secret_name']
+                    del connection_parameters['oauth_secret_name']
+                result = get_secrets(oauth_secrets_name,connection_parameters['other_secrets_name'])
+                connection_parameters['connection_secrets'] = result
+                del connection_parameters['other_secrets_name']
+                parameters = ConnectionConfigurationParameters.model_validate(connection_parameters)
+            else:
+                # deprecated way, where the sync engine passes the secrets directly
+                parameters = ConnectionConfigurationParameters.model_validate(connection_parameters)
+
+            # Pass the validated arguments to the function
+            return func(parameters, *args, **validated_args.dict())
+        
+        wrapper._is_omnata_consumer_udf = True
+        return wrapper
+    
+    return decorator