fix: add initial method for class bind

Author: qubka

lib/plugify/plugin.py

@@ -2,6 +2,8 @@
 import os
 import importlib.util
 from copy import deepcopy
+from enum import Enum
+from typing import Any, Callable, List, Optional, Dict, Tuple
 
 
 class Plugin:
@@ -189,7 +191,7 @@ def to_list(self):
         return deepcopy(self.m)
 
 
-def extract_required_modules(module_path, visited=None):
+def extract_required_modules(module_path: str, visited: Optional[set] = None):
     """
     Recursively extract all imported modules and their fully qualified names.
 
@@ -213,7 +215,7 @@ def extract_required_modules(module_path, visited=None):
     try:
         with open(module_path, "r", encoding="utf-8") as file:
             tree = ast.parse(file.read(), filename=module_path)
-        
+
         for node in ast.walk(tree):
             if isinstance(node, ast.Import):
                 for alias in node.names:
@@ -226,7 +228,7 @@ def extract_required_modules(module_path, visited=None):
         print(f"Error processing {module_path}: {e}")
         return required_modules
 
-    def find_module_path(module_name):
+    def find_module_path(module_name: str):
         """
         Locate the file path of a given Python module name, ensuring it's a .py file.
         """
@@ -239,8 +241,8 @@ def find_module_path(module_name):
             pass
         return None
 
+    all_dependencies = set(required_modules)
     try:
-        all_dependencies = set(required_modules)
         for module_name in required_modules:
             base_module = module_name.split('.')[0]
             module_file = find_module_path(base_module)
@@ -249,4 +251,203 @@ def find_module_path(module_name):
     except Exception as e:
         print(f"Error processing dependencies for {module_path}: {e}")
 
-    return all_dependencies
+    return all_dependencies
+
+
+class Ownership(Enum):
+    OWNED = True
+    BORROWED = False
+
+
+# Store class registry for retAlias lookups
+_class_registry = {}
+
+
+def bind_class_methods(
+        cls: type,
+        constructors: List[Callable],
+        destructor: Optional[Callable],
+        methods: List[Tuple[str, Callable, bool, Optional[List[Tuple[str, bool]]], Optional[Tuple[str, bool]]]],
+        invalid_value: Any = 0
+):
+    """
+    Dynamically bind methods to a class for RAII handle management.
+
+    Args:
+        cls: The class to extend with methods
+        constructors: List of constructor functions (can be empty for handle-only construction)
+        destructor: Destructor function (can be None)
+        methods: List of [name, func, bindSelf, paramAliases, retAlias]
+                 - name (str): Method name
+                 - func (callable): Underlying C function
+                 - bindSelf (bool): Whether to pass self._handle as first param
+                 - paramAliases (list): List of pairs with 'name' and 'owner' values
+                 - retAlias (dict): Pair with 'name' and 'owner' values
+        invalid_value: Value representing an invalid/closed handle (default: 0)
+    """
+
+    class_name = cls.__name__
+
+    # 1. Add __init__ method
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize the wrapper. Supports two modes:
+        1. Direct handle construction: ClassName(handle, Ownership.OWNED/BORROWED)
+        2. Constructor call: ClassName(*constructor_args)
+        """
+        # Check if this is handle + ownership construction
+        if len(args) >= 2 and isinstance(args[1], Ownership):
+            self._handle = args[0]
+            self._owned = args[1]
+        else:
+            # Constructor call
+            if len(constructors) == 0:
+                raise ValueError(f"{class_name} requires handle and ownership for construction")
+            elif len(constructors) == 1:
+                # Single constructor - call it directly
+                self._handle = constructors[0](*args, **kwargs)
+            else:
+                # Multiple constructors - first arg should be the constructor function
+                if len(args) == 0:
+                    raise ValueError(
+                        f"{class_name} with multiple constructors requires constructor function as first argument")
+                func = args[0]
+                if func not in constructors:
+                    raise ValueError(f"Invalid constructor function for {class_name}")
+                self._handle = func(*args[1:], **kwargs)
+
+            self._owned = Ownership.OWNED
+
+    cls.__init__ = __init__
+
+    # 2. Add lifecycle methods (close, __del__, __enter__, __exit__)
+    def close(self):
+        """Close/destroy the handle if owned."""
+        if self._handle != invalid_value and self._owned == Ownership.OWNED:
+            if destructor is not None:
+                destructor(self._handle)
+        self._handle = invalid_value
+        self._owned = Ownership.BORROWED
+
+    cls.close = close
+
+    def __del__(self):
+        self.close()
+
+    cls.__del__ = __del__
+
+    def __enter__(self):
+        return self
+
+    cls.__enter__ = __enter__
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False
+
+    cls.__exit__ = __exit__
+
+    # 3. Add utility methods (release, reset, get, valid)
+    def release(self) -> Any:
+        """Release ownership of the handle and return it."""
+        tmp = self._handle
+        self._handle = invalid_value
+        self._owned = Ownership.BORROWED
+        return tmp
+
+    cls.release = release
+
+    def reset(self):
+        """Reset the handle by closing it."""
+        self.close()
+
+    cls.reset = reset
+
+    def get(self) -> Any:
+        """Get the raw handle value without transferring ownership."""
+        return self._handle
+
+    cls.get = get
+
+    def valid(self) -> bool:
+        """Check if the handle is valid."""
+        return self._handle != invalid_value
+
+    cls.valid = valid
+
+    # Register this class for retAlias lookups
+    _class_registry[class_name] = cls
+
+    # 4. Add bound methods from the methods list
+    for method_info in methods:
+        method_name = method_info[0]
+        func = method_info[1]
+        bind_self = method_info[2]
+        param_aliases = method_info[3]
+        ret_alias = method_info[4]
+
+        # Create the bound method with closure over parameters
+        def create_method(
+                func: Callable,
+                bind_self: bool,
+                param_aliases: Optional[List[Tuple[str, bool]]],
+                ret_alias: Optional[Tuple[str, bool]],
+                method_name: str
+        ):
+            def method(self, *args, **kwargs):
+                # Check if handle is valid
+                if self._handle == invalid_value:
+                    raise RuntimeError(f"{class_name} handle is closed")
+
+                # Process arguments - convert to list for modification
+                args_list = list(args)
+
+                # Handle paramAliases - extract handles from wrapper objects
+                if param_aliases:
+                    for i, alias_info in enumerate(param_aliases):
+                        if alias_info and i < len(args_list):
+                            alias_name = alias_info[0]
+                            owner = alias_info[1]
+
+                            if alias_name and args_list[i] is not None:
+                                arg = args_list[i]
+                                # Check if the argument has the expected methods
+                                if hasattr(arg, 'release') and hasattr(arg, 'get'):
+                                    if owner:
+                                        # Transfer ownership - use release()
+                                        args_list[i] = arg.release()
+                                    else:
+                                        # Borrow - use get()
+                                        args_list[i] = arg.get()
+
+                # Call the underlying function
+                if bind_self:
+                    # Pass self._handle as first parameter
+                    result = func(self._handle, *args_list, **kwargs)
+                else:
+                    # Don't pass self._handle
+                    result = func(*args_list, **kwargs)
+
+                # Handle retAlias - wrap return value in class
+                if ret_alias:
+                    ret_name = ret_alias[0]
+                    owner = ret_alias[1]
+
+                    # Look up the class
+                    ret_class = _class_registry.get(ret_name)
+                    if ret_class and result != invalid_value:
+                        ownership = Ownership.OWNED if owner else Ownership.BORROWED
+                        return ret_class(result, ownership)
+                    elif result == invalid_value:
+                        return None
+
+                return result
+
+            # Preserve function name for better debugging
+            method.__name__ = method_name
+            return method
+
+        # Bind the method to the class
+        setattr(cls, method_name, create_method(func, bind_self, param_aliases, ret_alias, method_name))
+
+    return cls

src/module.cpp

@@ -3215,6 +3215,13 @@ namespace py3lm {
 			return MakeError("Failed to find plugify.plugin.extract_required_modules function");
 		}
 
+		_BindClassMethodsObject = PyObject_GetAttrString(plugifyPluginModule, "bind_class_methods");
+		if (!_BindClassMethodsObject || !PyCallable_Check(_BindClassMethodsObject)) {
+			Py_DECREF(plugifyPluginModule);
+			LogError();
+			return MakeError("Failed to find plugify.plugin.bind_class_methods function");
+		}
+
 		Py_DECREF(plugifyPluginModule);
 
 		_ppsModule = PyImport_ImportModule("plugify.pps");
@@ -3376,6 +3383,10 @@ namespace py3lm {
 				Py_DECREF(_ExtractRequiredModulesObject);
 			}
 
+			if (_BindClassMethodsObject) {
+				Py_DECREF(_BindClassMethodsObject);
+			}
+
 			if (_PluginTypeObject) {
 				Py_DECREF(_PluginTypeObject);
 			}
@@ -3414,6 +3425,7 @@ namespace py3lm {
 		_Vector4TypeObject = nullptr;
 		_Matrix4x4TypeObject = nullptr;
 		_ExtractRequiredModulesObject = nullptr;
+		_BindClassMethodsObject = nullptr;
 		_PluginTypeObject = nullptr;
 		_PluginInfoTypeObject = nullptr;
 		_internalMap.clear();

src/module.hpp

@@ -181,6 +181,7 @@ namespace py3lm {
 		PyObject* _Vector4TypeObject = nullptr;
 		PyObject* _Matrix4x4TypeObject = nullptr;
 		PyObject* _ExtractRequiredModulesObject = nullptr;
+		PyObject* _BindClassMethodsObject = nullptr;
 		PyObject* _ppsModule = nullptr;
 		PyObject* _enumModule = nullptr;
 		PyObject* _formatException = nullptr;