Update main_app.py

main_app.py

@@ -419,65 +419,34 @@ def _(function_editor, mo, os):
     if function_editor.value:
         # Get the edited code from the function editor
         code = function_editor.value['editor']
+        
+        # Extract function name using AST without executing the code
 
-        ### Safe Import pass - this bypasses the issue of exec(code,namespace) conflicting when a package isn't in this hugging face environment.
-        def safe_import(name, *args, **kwargs):
-            try:
-                return __import__(name, *args, **kwargs)
-            except ImportError:
-                # Create a dummy module that returns itself for any attribute
-                import sys
-                import types
-                
-                # Create a proper module object rather than a class
-                dummy = types.ModuleType(name)
-                
-                # Make the module return itself for any attribute
-                def __getattr__(attr):
-                    return dummy
-                dummy.__getattr__ = __getattr__
-                
-                # Register in sys.modules to handle nested imports
-                sys.modules[name] = dummy
-                
-                # Also register parent modules
-                if '.' in name:
-                    parts = name.split('.')
-                    for i in range(1, len(parts)):
-                        parent_name = '.'.join(parts[:i])
-                        if parent_name not in sys.modules:
-                            parent = types.ModuleType(parent_name)
-                            parent.__getattr__ = lambda attr: dummy if attr == parts[i] else parent
-                            sys.modules[parent_name] = parent
+        try:
+            # Parse the code to find function definitions
+            parsed_ast = ast.parse(code)
+            function_name = None
+            for node in parsed_ast.body:
+                if isinstance(node, ast.FunctionDef):
+                    function_name = node.name
+                    break
+            
+            if function_name:
+                # Set deployable_function to None since we're not executing the code
+                deployable_function = None
+                mo.md(f"Found function: '{function_name}' (using file path approach)")
                 
-                return dummy
-                    
-        # Create a namespace to execute the code in
-        namespace = {'__builtins__': __builtins__, '__import__': safe_import}
-        # Execute the code
-        exec(code, namespace)
-
-        # Find the first function defined in the namespace
-        function_name = None
-        for name, obj in namespace.items():
-            if callable(obj) and name != "__builtins__":
-                function_name = name
-                break
-
-        if function_name:
-            # Instantiate the deployable function
-            deployable_function = namespace[function_name]
-            # Now deployable_function contains the score function
-            mo.md(f"Created deployable function from '{function_name}'")
-            # Create the directory if it doesn't exist
-            save_dir = "/tmp/notebook_functions"
-            os.makedirs(save_dir, exist_ok=True)
-            # Save the function code to a file
-            file_path = os.path.join(save_dir, f"{function_name}.py")
-            with open(file_path, "w") as f:
-                f.write(code)
-        else:
-            mo.md("No function found in the editor code")
+                # Create the directory if it doesn't exist
+                save_dir = "/tmp/notebook_functions"
+                os.makedirs(save_dir, exist_ok=True)
+                # Save the function code to a file
+                file_path = os.path.join(save_dir, f"{function_name}.py")
+                with open(file_path, "w") as f:
+                    f.write(code)
+            else:
+                mo.md("No function found in the editor code")
+        except SyntaxError as e:
+            mo.md(f"Syntax error in function code: {str(e)}")
     return (
         code,
         deployable_function,
@@ -806,7 +775,7 @@ def _(
                 # If JSON parsing fails, try Python literal evaluation as fallback
                 function_meta[deployment_client.repository.FunctionMetaNames.SAMPLE_SCORING_INPUT] = ast.literal_eval(sample_input_editor.value)
 
-    def upload_function(function_meta, use_function_object=True):
+    def upload_function(function_meta, use_function_object=False):
         """
         Uploads a Python function to watsonx.ai as a deployable asset.
         Parameters:
@@ -873,7 +842,7 @@ def _(
 
     upload_button = mo.ui.button(
         label="Upload Function",
-        on_click=lambda _: upload_function(function_meta, use_function_object=True),
+        on_click=lambda _: upload_function(function_meta, use_function_object=False),
         kind="success",
         tooltip="Click to upload function to watsonx.ai"
     )