procedure: Provide workaround for argument types representing GIMP-related objects

For arguments such as `Gegl.Color`, one must pass arguments as a function returning a list (a new feature) or call `Gegl.init()` at the module level before registering plug-in procedures.

Author: kamilburda

README.md

@@ -127,6 +127,8 @@ Within the main file of your plug-in (a Python script with same name as its pare
 
 At the end of your main Python file (`some-plug-in.py` in the example above), call `procedure.main()`.
 
+For some argument/return value types, e.g. `Gegl.Color`, the default value can be a valid `Gegl.Color` object. In that case, you must call `Gegl.init()` first before instantiating the default objects as otherwise plug-in registration will fail (the plug-in will crash). Alternatively, you can pass a function returning a list to the `arguments` parameter rather than the list itself to delay the creation of the default values until it's necessary, at which point `Gegl.init()` will have been automatically called already.
+
 
 ## Regenerating the `pypdb.pyi` stub file
 

wrappers/procedure.py

@@ -27,15 +27,15 @@
 def register_procedure(
       procedure: Callable,
       procedure_type: Type[Gimp.Procedure] = Gimp.ImageProcedure,
-      arguments: Optional[Iterable[List]] = None,
-      return_values: Optional[Iterable[List]] = None,
+      arguments: Optional[Union[Iterable[List], Callable[[], Iterable[List]]]] = None,
+      return_values: Optional[Union[Iterable[List], Callable[[], Iterable[List]]]] = None,
       menu_label: Optional[str] = None,
       menu_path: Optional[Union[str, Iterable[str]]] = None,
       image_types: Optional[str] = None,
       sensitivity_mask: Optional[Gimp.ProcedureSensitivityMask] = None,
       documentation: Optional[Union[Tuple[str, str], Tuple[str, str, str]]] = None,
       attribution: Optional[Tuple[str, str, str]] = None,
-      auxiliary_arguments: Optional[Iterable[List]] = None,
+      auxiliary_arguments: Optional[Union[Iterable[List], Callable[[], Iterable[List]]]] = None,
       run_data: Optional[Iterable] = None,
       init_ui: bool = True,
       pdb_procedure_type: Gimp.PDBProcType = Gimp.PDBProcType.PLUGIN,
@@ -69,7 +69,8 @@ def register_procedure(
       registered. If ``procedure_type`` is `Gimp.ImageProcedure`, several PDB
       arguments will be pre-filled (see the documentation for
       `Gimp.ImageProcedure` for more information).
-    arguments: List of arguments (procedure parameters).
+    arguments: List of arguments (procedure parameters), or a function returning
+      a list of arguments.
       Each argument must be a list containing the following elements in this
       order:
       * argument type. The type corresponds to one of the
@@ -82,9 +83,40 @@ def register_procedure(
       Underscores in argument names (``_``) are automatically replaced with
       hyphens (``-``).
 
+      If your argument list contains arguments of type e.g. `Gegl.Color`, you
+      will have to pass a function taking no parameters, for example:
+      >>> def get_arguments():
+      >>>   _default_foreground_color = Gegl.Color.new('black')
+      >>>   _default_foreground_color.set_rgba(0.65, 0.6, 0.3, 1.0)
+      >>>
+      >>>   _default_background_color = Gegl.Color.new('black')
+      >>>   _default_background_color.set_rgba(0.1, 0.4, 0.15, 1.0)
+      >>>
+      >>>   return [
+      >>>     [
+      >>>       'color',
+      >>>       'foreground-color',
+      >>>       'Foreground color',
+      >>>       'Foreground color',
+      >>>       True,
+      >>>       _default_foreground_color,
+      >>>       GObject.ParamFlags.READWRITE,
+      >>>     ],
+      >>>     [
+      >>>       'color',
+      >>>       'background-color',
+      >>>       'Background color',
+      >>>       'Background color',
+      >>>       True,
+      >>>       _default_background_color,
+      >>>       GObject.ParamFlags.READWRITE,
+      >>>     ],
+      >>>   ]
+
       For documentation on the ``Gimp.Procedure.add_*_argument`` functions, see:
       https://lazka.github.io/pgi-docs/#Gimp-3.0/classes/Procedure.html
-    return_values: List of return values.
+    return_values: List of return values, or a function returning a list of
+      return values.
       See ``arguments`` for more information about the contents and format of
       the list.
 
@@ -111,7 +143,8 @@ def register_procedure(
       specify it explicitly.
     attribution: Plug-in authors, copyright notice and date.
       This is a tuple of (authors, copyright notice, date) strings.
-    auxiliary_arguments: List of auxiliary arguments.
+    auxiliary_arguments: List of auxiliary arguments, or a function returning
+      a list of auxiliary arguments.
       See ``arguments`` for more information about the contentsn and format of
       the list.
 
@@ -204,15 +237,15 @@ def register_procedure(
   proc_dict = _PROCEDURE_NAMES_AND_DATA[proc_name]
   proc_dict['procedure'] = procedure
   proc_dict['procedure_type'] = procedure_type
-  proc_dict['arguments'] = _parse_and_check_parameters(arguments)
-  proc_dict['return_values'] = _parse_and_check_parameters(return_values)
+  proc_dict['arguments'] = arguments
+  proc_dict['return_values'] = return_values
   proc_dict['menu_label'] = menu_label
   proc_dict['menu_path'] = menu_path
   proc_dict['image_types'] = image_types
   proc_dict['sensitivity_mask'] = sensitivity_mask
   proc_dict['documentation'] = documentation
   proc_dict['attribution'] = attribution
-  proc_dict['auxiliary_arguments'] = _parse_and_check_parameters(auxiliary_arguments)
+  proc_dict['auxiliary_arguments'] = auxiliary_arguments
   proc_dict['run_data'] = run_data
   proc_dict['init_ui'] = init_ui
   proc_dict['pdb_procedure_type'] = pdb_procedure_type
@@ -227,12 +260,17 @@ def _parse_and_check_parameters(parameters):
   if parameters is None:
     return None
 
-  if not isinstance(parameters, Iterable):
+  if callable(parameters):
+    processed_parameters = parameters()
+  else:
+    processed_parameters = parameters
+
+  if not isinstance(processed_parameters, Iterable):
     raise TypeError('Arguments and return values must be specified as a list-like iterable')
 
-  processed_parameters = {}
+  parsed_parameters = {}
 
-  for param in parameters:
+  for param in processed_parameters:
     processed_param = list(param)
 
     if isinstance(processed_param, list):
@@ -249,14 +287,14 @@ def _parse_and_check_parameters(parameters):
 
       name = processed_param.pop(1).replace('_', '-')
 
-      if name in processed_parameters:
+      if name in parsed_parameters:
         raise ValueError(f'Argument or return value named "{name}" was already specified')
 
-      processed_parameters[name] = processed_param
+      parsed_parameters[name] = processed_param
     else:
       raise TypeError('Only lists are allowed when specifying an argument or return value')
 
-  return processed_parameters
+  return parsed_parameters
 
 
 def set_use_locale(enabled):
@@ -337,6 +375,8 @@ def _do_query_procedures(_plugin_instance):
 
 
 def _do_create_procedure(plugin_instance, proc_name):
+  Gegl.init(None)
+
   if proc_name in _PROCEDURE_NAMES_AND_DATA:
     proc_dict = _PROCEDURE_NAMES_AND_DATA[proc_name]
   else:
@@ -386,17 +426,23 @@ def _do_create_procedure(plugin_instance, proc_name):
     )
 
   if proc_dict['arguments'] is not None:
-    for name, params in proc_dict['arguments'].items():
+    parsed_arguments = _parse_and_check_parameters(proc_dict['arguments'])
+
+    for name, params in parsed_arguments.items():
       param_type = params.pop(0)
       _get_add_param_func(procedure, param_type, 'argument')(name, *params)
 
   if proc_dict['return_values'] is not None:
-    for name, params in proc_dict['return_values'].items():
+    parsed_return_values = _parse_and_check_parameters(proc_dict['return_values'])
+
+    for name, params in parsed_return_values.items():
       param_type = params.pop(0)
       _get_add_param_func(procedure, param_type, 'return_value')(name, *params)
 
   if proc_dict['auxiliary_arguments'] is not None:
-    for name, params in proc_dict['auxiliary_arguments'].items():
+    parsed_auxiliary_arguments = _parse_and_check_parameters(proc_dict['auxiliary_arguments'])
+
+    for name, params in parsed_auxiliary_arguments.items():
       param_type = params.pop(0)
       _get_add_param_func(procedure, param_type, 'aux_argument')(name, *params)
 
@@ -464,8 +510,6 @@ def func_wrapper(*procedure_and_args):
     if init_ui and run_mode == Gimp.RunMode.INTERACTIVE:
       GimpUi.init(procedure.get_name())
 
-    Gegl.init()
-
     return_values = func(*procedure_and_args)
 
     if return_values is None: