Inline ArrayWrapper classes into generated modules (WIP)

Changed approach from separate ArrayWrappers module to inlining the wrapper classes directly into each generated module. This eliminates the ModuleNotFoundError issues.

Changes:
- Removed cimport from ArrayWrappers
- Added inline_array_wrappers() to inject wrapper code into generated modules
- Removed ArrayWrappers compilation logic from Utils.py

Status: Compilation succeeds but attribute injection has indentation issues that need fixing.
The regex-based approach for merging .pxd attributes into .pyx classes needs refinement.

Co-authored-by: jpfeuffer <8102638+jpfeuffer@users.noreply.github.com>

Author: Copilot

autowrap/CodeGenerator.py

@@ -2096,17 +2096,6 @@ def create_default_cimports(self):
                    |import numpy as np
                    |cimport numpy as numpy
                    |import numpy as numpy
-                   |from ArrayWrappers cimport (
-                   |    ArrayWrapperFloat, ArrayWrapperDouble,
-                   |    ArrayWrapperInt8, ArrayWrapperInt16, ArrayWrapperInt32, ArrayWrapperInt64,
-                   |    ArrayWrapperUInt8, ArrayWrapperUInt16, ArrayWrapperUInt32, ArrayWrapperUInt64,
-                   |    ArrayViewFloat, ArrayViewDouble,
-                   |    ArrayViewInt8, ArrayViewInt16, ArrayViewInt32, ArrayViewInt64,
-                   |    ArrayViewUInt8, ArrayViewUInt16, ArrayViewUInt32, ArrayViewUInt64,
-                   |    _create_view_float, _create_view_double,
-                   |    _create_view_int8, _create_view_int16, _create_view_int32, _create_view_int64,
-                   |    _create_view_uint8, _create_view_uint16, _create_view_uint32, _create_view_uint64
-                   |)
                    """
             )
 
@@ -2119,7 +2108,71 @@ def create_std_cimports(self):
                 code.add(stmt)
 
         self.top_level_code.append(code)
+        
+        # If numpy is enabled, inline the ArrayWrapper/ArrayView classes
+        if self.include_numpy:
+            self.inline_array_wrappers()
+        
         return code
+    
+    def inline_array_wrappers(self):
+        """Inline ArrayWrapper and ArrayView class definitions for buffer protocol support."""
+        # Read both the .pyx and .pxd files
+        autowrap_dir = os.path.dirname(os.path.abspath(__file__))
+        array_wrappers_pyx = os.path.join(autowrap_dir, "data_files", "autowrap", "ArrayWrappers.pyx")
+        array_wrappers_pxd = os.path.join(autowrap_dir, "data_files", "autowrap", "ArrayWrappers.pxd")
+        
+        if not os.path.exists(array_wrappers_pyx):
+            L.warning("ArrayWrappers.pyx not found, skipping inline array wrappers")
+            return
+        
+        with open(array_wrappers_pyx, 'r') as f:
+            pyx_content = f.read()
+        
+        # Read .pxd to get attribute declarations
+        attribute_declarations = {}
+        if os.path.exists(array_wrappers_pxd):
+            with open(array_wrappers_pxd, 'r') as f:
+                pxd_content = f.read()
+            
+            # Parse .pxd to extract attribute declarations for each class
+            import re
+            # Pattern to match class declarations with their attributes
+            # Match: "cdef class ClassName:\n    cdef type attr\n    cdef type attr\n..."
+            class_pattern = r'cdef class (\w+):\s*\n((?:\s+cdef .+\n)+)'
+            for match in re.finditer(class_pattern, pxd_content):
+                class_name = match.group(1)
+                attrs = match.group(2)
+                # Attrs already has proper indentation from .pxd
+                attribute_declarations[class_name] = attrs.rstrip()
+        
+        # Now inject the attribute declarations into the .pyx content
+        # For each class, add the cdef attributes right after the docstring
+        for class_name, attrs in attribute_declarations.items():
+            # Find "cdef class ClassName:" and its docstring, then add attributes after
+            pattern = rf'(cdef class {class_name}:\s+""".*?""")\s*\n'
+            replacement = rf'\1\n{attrs}\n    '
+            pyx_content = re.sub(pattern, replacement, pyx_content, flags=re.DOTALL)
+        
+        # Remove the first few lines (cython directives and module docstring)
+        # Keep everything from the first import onward
+        lines = pyx_content.split('\n')
+        start_idx = 0
+        for i, line in enumerate(lines):
+            if line.strip().startswith('from cpython.buffer'):
+                start_idx = i
+                break
+        
+        wrapper_code_str = '\n'.join(lines[start_idx:])
+        
+        code = Code()
+        code.add("""
+                |# Inlined ArrayWrapper and ArrayView classes for buffer protocol support
+                """)
+        # Add the wrapper code directly
+        code.add(wrapper_code_str)
+        
+        self.top_level_code.append(code)
 
     def create_includes(self):
         code = Code()

autowrap/Utils.py

@@ -178,22 +178,8 @@ def compile_and_import(name, source_files, include_dirs=None, **kws):
         print("tempdir=", tempdir)
         print("\n")
 
-    # Check if any source file imports ArrayWrappers (indicates numpy usage)
-    needs_array_wrappers = False
-    for source_file in source_files:
-        if source_file.endswith('.pyx'):
-            try:
-                with open(source_file, 'r') as f:
-                    content = f.read()
-                    if 'ArrayWrappers' in content or 'ArrayWrapper' in content or 'ArrayView' in content:
-                        needs_array_wrappers = True
-                        break
-            except:
-                pass
-    
-    # Compile ArrayWrappers first if needed
-    if needs_array_wrappers:
-        _compile_array_wrappers_if_needed(tempdir, include_dirs, debug)
+    # Note: ArrayWrappers classes are now inlined into generated modules,
+    # so we don't need to compile them separately anymore
 
     for source_file in source_files:
         if source_file[-4:] != ".pyx" and source_file[-4:] != ".cpp":