From 4c7dc3e5c5423ec20ca69841e49718fbae02a22d Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Fri, 13 Nov 2009 09:28:05 +0000 Subject: changes python initialization - bpy is now a python package, this makes it easier to add utility modules and adjust python startup which was previously using verbose Py/C api. Access should not be any slower since both C and Python modules use dictionary access. - loop over scripts and load via python (currently F8 reload isnt working, will add back shortly) - the C module is kept but renamed to _bpy and not meant for direct access from anything but the bpy package. - bpy_types.py is an exception since it runs before the bpy package is initialized. --- release/scripts/modules/bpy/ops.py | 197 +++++++++++++++++++++++++++++++++++++ 1 file changed, 197 insertions(+) create mode 100644 release/scripts/modules/bpy/ops.py (limited to 'release/scripts/modules/bpy/ops.py') diff --git a/release/scripts/modules/bpy/ops.py b/release/scripts/modules/bpy/ops.py new file mode 100644 index 00000000000..e3fa2ab94ca --- /dev/null +++ b/release/scripts/modules/bpy/ops.py @@ -0,0 +1,197 @@ +# ##### BEGIN GPL LICENSE BLOCK ##### +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# ##### END GPL LICENSE BLOCK ##### + +# + +# for slightly faster access +from _bpy import ops as ops_module + +op_add = ops_module.add +op_remove = ops_module.remove +op_dir = ops_module.dir +op_call = ops_module.call +op_as_string = ops_module.as_string +op_get_rna = ops_module.get_rna + +# Keep in sync with WM_types.h +context_dict = { + 'INVOKE_DEFAULT': 0, + 'INVOKE_REGION_WIN': 1, + 'INVOKE_AREA': 2, + 'INVOKE_SCREEN': 3, + 'EXEC_DEFAULT': 4, + 'EXEC_REGION_WIN': 5, + 'EXEC_AREA': 6, + 'EXEC_SCREEN': 7, +} + + +class bpy_ops(object): + ''' + Fake module like class. + + bpy.ops + ''' + + def __getattr__(self, module): + ''' + gets a bpy.ops submodule + ''' + if module.startswith('__'): + raise AttributeError(module) + return bpy_ops_submodule(module) + + def add(self, pyop): + op_add(pyop) + + def remove(self, pyop): + op_remove(pyop) + + def __dir__(self): + + submodules = set() + + # add this classes functions + for id_name in dir(self.__class__): + if not id_name.startswith('__'): + submodules.add(id_name) + + for id_name in op_dir(): + id_split = id_name.split('_OT_', 1) + + if len(id_split) == 2: + submodules.add(id_split[0].lower()) + else: + submodules.add(id_split[0]) + + return list(submodules) + + def __repr__(self): + return "" + + +class bpy_ops_submodule(object): + ''' + Utility class to fake submodules. + + eg. bpy.ops.object + ''' + __keys__ = ('module',) + + def __init__(self, module): + self.module = module + + def __getattr__(self, func): + ''' + gets a bpy.ops.submodule function + ''' + if func.startswith('__'): + raise AttributeError(func) + return bpy_ops_submodule_op(self.module, func) + + def __dir__(self): + + functions = set() + + module_upper = self.module.upper() + + for id_name in op_dir(): + id_split = id_name.split('_OT_', 1) + if len(id_split) == 2 and module_upper == id_split[0]: + functions.add(id_split[1]) + + return list(functions) + + def __repr__(self): + return "" % self.module + + +class bpy_ops_submodule_op(object): + ''' + Utility class to fake submodule operators. + + eg. bpy.ops.object.somefunc + ''' + + __keys__ = ('module', 'func') + + + def _get_doc(self): + return op_as_string(self.idname()) + + __doc__ = property(_get_doc) + + def __init__(self, module, func): + self.module = module + self.func = func + + def idname(self): + # submod.foo -> SUBMOD_OT_foo + return self.module.upper() + '_OT_' + self.func + + def __call__(self, *args, **kw): + + # Get the operator from blender + if len(args) > 2: + raise ValueError("1 or 2 args execution context is supported") + + C_dict = None + + if args: + + C_exec = 'EXEC_DEFAULT' + + if len(args) == 2: + C_exec = args[0] + C_dict = args[1] + else: + if type(args[0]) != str: + C_dict = args[0] + else: + C_exec = args[0] + + try: + context = context_dict[C_exec] + except: + raise ValueError("Expected a single context argument in: " + \ + str(list(context_dict.keys()))) + + if len(args) == 2: + C_dict = args[1] + + return op_call(self.idname(), C_dict, kw, context) + + else: + return op_call(self.idname(), C_dict, kw) + + def get_rna(self): + ''' + currently only used for 'bl_rna' + ''' + return op_get_rna(self.idname()) + + def __repr__(self): # useful display, repr(op) + return op_as_string(self.idname()) + + def __str__(self): # used for print(...) + return "" % \ + (self.module, self.func, id(self)) + +import bpy +bpy.ops = bpy_ops() + -- cgit v1.2.3