Python operators
authorCampbell Barton <ideasman42@gmail.com>
Sun, 19 Jul 2009 13:32:02 +0000 (13:32 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sun, 19 Jul 2009 13:32:02 +0000 (13:32 +0000)
- simplified C operator API bpy.__ops__ since its wrapped by python now.
- needs the class to have an __idname__ rather then __name__ (like menus, headers)
- convert python names "console.exec" into blender names "CONSOLE_OT_exec" when registering (store the blender name as class.__idname_bl__, users scripters wont notice)
- bpy.props.props ???, removed

release/io/export_ply.py
release/ui/bpy_ops.py
release/ui/space_console.py
source/blender/editors/space_view3d/space_view3d.c
source/blender/python/intern/bpy_operator.c
source/blender/python/intern/bpy_operator_wrap.c
source/blender/python/intern/bpy_rna.c
source/blender/python/intern/bpy_util.c
source/blender/python/intern/bpy_util.h

index ed983c2b1695d8897826de6144170fe35c0d3717..6fdf4bf41b99742a9d5b8f83582c751dc0eaa7a3 100644 (file)
@@ -240,6 +240,7 @@ class EXPORT_OT_ply(bpy.types.Operator):
        '''
        Operator documentatuon text, will be used for the operator tooltip and python docs.
        '''
+       __idname__ = "export.ply"
        __label__ = "Export PLY"
        
        # List of operator properties, the attributes will be assigned
index 22b7846a671595659220199d041453a983c3c4e5..084f4c9703b85ed9c4e3a82059ad678816271385 100644 (file)
@@ -1,7 +1,8 @@
-import bpy
-
-# This class is used for bpy.ops
-#
+# for slightly faster access
+from bpy.__ops__ import add            as op_add
+from bpy.__ops__ import remove         as op_remove
+from bpy.__ops__ import dir            as op_dir
+from bpy.__ops__ import call           as op_call
 
 class bpy_ops(object):
        '''
@@ -10,10 +11,10 @@ class bpy_ops(object):
         bpy.ops
        '''
        def add(self, pyop):
-               bpy.__ops__.add(pyop)
+               op_add(pyop)
        
        def remove(self, pyop):
-               bpy.__ops__.remove(pyop)
+               op_remove(pyop)
        
        def __getattr__(self, module):
                '''
@@ -25,11 +26,8 @@ class bpy_ops(object):
                
                submodules = set()
                
-               for id_name in dir(bpy.__ops__):
+               for id_name in op_dir():
                        
-                       if id_name.startswith('__'):
-                               continue
-                               
                        id_split = id_name.split('_OT_', 1)
                        
                        if len(id_split) == 2:
@@ -66,7 +64,7 @@ class bpy_ops_submodule(object):
                
                module_upper = self.module.upper()
                
-               for id_name in dir(bpy.__ops__):
+               for id_name in op_dir():
                        
                        if id_name.startswith('__'):
                                continue
@@ -96,12 +94,10 @@ class bpy_ops_submodule_op(object):
                id_name = self.module.upper() + '_OT_' + self.func
                
                # Get the operator from 
-               internal_op = getattr(bpy.__ops__, id_name)
-               
-               # Call the op
-               return internal_op(**kw)
+               return op_call(id_name, kw)
                
        def __repr__(self):
                return "<function bpy.ops.%s.%s at 0x%x'>" % (self.module, self.func, id(self))
 
+import bpy
 bpy.ops = bpy_ops()
index 189943520346615d2d112c4c00071e60b316cbec..d6078b1db801fa6053d3a779b518db68dd2eb3f3 100644 (file)
@@ -120,6 +120,7 @@ class CONSOLE_OT_exec(bpy.types.Operator):
        '''
        Operator documentatuon text, will be used for the operator tooltip and python docs.
        '''
+       __idname__ = "console.exec"
        __label__ = "Console Execute"
        __register__ = False
        
@@ -396,6 +397,7 @@ class CONSOLE_OT_autocomplete(bpy.types.Operator):
        '''
        Operator documentatuon text, will be used for the operator tooltip and python docs.
        '''
+       __idname__ = "console.autocomplete"
        __label__ = "Console Autocomplete"
        __register__ = False
        
index a8abdf4132ec14ea5bfdeaf7b1c47916b958379c..2b162f9574d36090b602cec40acdb66762df45cd 100644 (file)
@@ -52,6 +52,7 @@
 #include "ED_armature.h"
 #include "ED_space_api.h"
 #include "ED_screen.h"
+#include "ED_object.h"
 
 #include "BIF_gl.h"
 
index b57ef54304b7c6937eb9c7a556eee53af044c33a..240ce2030bae0cb18fb386e06f52920481b091f4 100644 (file)
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/* Note, this module is not to be used directly by the user.
+ * its accessed from blender with bpy.__ops__
+ * */
+
 #include "bpy_operator.h"
 #include "bpy_operator_wrap.h"
 #include "bpy_rna.h" /* for setting arg props only - pyrna_py_to_prop() */
 #include "bpy_compat.h"
 #include "bpy_util.h"
 
-//#include "blendef.h"
-#include "BLI_dynstr.h"
-
 #include "WM_api.h"
 #include "WM_types.h"
 
 #include "MEM_guardedalloc.h"
-//#include "BKE_idprop.h"
 #include "BKE_report.h"
 
-extern ListBase global_ops; /* evil, temp use */
-
-static PyObject *pyop_base_dir(PyObject *self);
-static PyObject *pyop_base_rna(PyObject *self, PyObject *pyname);
-static struct PyMethodDef pyop_base_methods[] = {
-       {"__dir__", (PyCFunction)pyop_base_dir, METH_NOARGS, ""},
-       {"__rna__", (PyCFunction)pyop_base_rna, METH_O, ""},
-       {"add", (PyCFunction)PYOP_wrap_add, METH_O, ""},
-       {"remove", (PyCFunction)PYOP_wrap_remove, METH_O, ""},
-       {NULL, NULL, 0, NULL}
-};
 
 /* 'self' stores the operator string */
-static PyObject *pyop_base_call( PyObject * self, PyObject * args,  PyObject * kw)
+static PyObject *pyop_call( PyObject * self, PyObject * args)
 {
        wmOperatorType *ot;
        int error_val = 0;
        PointerRNA ptr;
        
+       char *opname;
+       PyObject *kw= NULL;
+
        // XXX Todo, work out a better solution for passing on context, could make a tuple from self and pack the name and Context into it...
        bContext *C = BPy_GetContext();
        
-       char *opname = _PyUnicode_AsString(self);
 
-       if (PyTuple_Size(args)) {
-               PyErr_SetString( PyExc_AttributeError, "All operator args must be keywords");
+       switch(PyTuple_Size(args)) {
+       case 2:
+               kw = PyTuple_GET_ITEM(args, 1);
+
+               if(!PyDict_Check(kw)) {
+                       PyErr_SetString( PyExc_AttributeError, "bpy.__ops__.call: expected second arg to be a dict");
+                       return NULL;
+               }
+               /* pass through */
+       case 1:
+               opname = _PyUnicode_AsString(PyTuple_GET_ITEM(args, 0));
+
+               if(opname==NULL) {
+                       PyErr_SetString( PyExc_AttributeError, "bpy.__ops__.call: expected the first arg to be a string");
+                       return NULL;
+               }
+               break;
+       default:
+               PyErr_SetString( PyExc_AttributeError, "bpy.__ops__.call: expected a string and optional dict");
                return NULL;
        }
 
+
        ot= WM_operatortype_find(opname, 1);
+
        if (ot == NULL) {
-               PyErr_Format( PyExc_SystemError, "Operator \"%s\"could not be found", opname);
+               PyErr_Format( PyExc_SystemError, "bpy.__ops__.call: operator \"%s\"could not be found", opname);
                return NULL;
        }
        
        if(ot->poll && (ot->poll(C) == 0)) {
-               PyErr_SetString( PyExc_SystemError, "Operator poll() function failed, context is incorrect");
+               PyErr_SetString( PyExc_SystemError, "bpy.__ops__.call: operator poll() function failed, context is incorrect");
                return NULL;
        }
        
-       WM_operator_properties_create(&ptr, opname);
+       /* WM_operator_properties_create(&ptr, opname); */
+       /* Save another lookup */
+       RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
        
-       error_val= pyrna_pydict_to_props(&ptr, kw, "Converting py args to operator properties: ");
+       if(kw && PyDict_Size(kw))
+               error_val= pyrna_pydict_to_props(&ptr, kw, "Converting py args to operator properties: ");
+
        
        if (error_val==0) {
                ReportList reports;
@@ -118,96 +132,34 @@ static PyObject *pyop_base_call( PyObject * self, PyObject * args,  PyObject * k
        Py_RETURN_NONE;
 }
 
-static PyMethodDef pyop_base_call_meth[] = {
-       {"__op_call__", (PyCFunction)pyop_base_call, METH_VARARGS|METH_KEYWORDS, "generic operator calling function"}
-};
-
-
-//---------------getattr--------------------------------------------
-static PyObject *pyop_base_getattro( BPy_OperatorBase * self, PyObject *pyname )
-{
-       char *name = _PyUnicode_AsString(pyname);
-       PyObject *ret;
-       wmOperatorType *ot;
-       
-       /* First look for the operator, then our own methods if that fails.
-        * when methods are searched first, PyObject_GenericGetAttr will raise an error
-        * each time we want to call an operator, we could clear the error but I prefer
-        * not to since calling operators is a lot more common then adding and removing. - Campbell */
-       
-       if ((ot= WM_operatortype_find(name, 1))) {
-               ret = PyCFunction_New( pyop_base_call_meth, pyname); /* set the name string as self, PyCFunction_New incref's self */
-       }
-       else if ((ret = PyObject_GenericGetAttr((PyObject *)self, pyname))) {
-               /* do nothing, this accounts for methoddef's add and remove
-                * An exception is raised when PyObject_GenericGetAttr fails
-                * but its ok because its overwritten below */
-       }
-       else {
-               PyErr_Format( PyExc_AttributeError, "Operator \"%s\" not found", name);
-               ret= NULL;
-       }
-
-       return ret;
-}
-
-static PyObject *pyop_base_dir(PyObject *self)
+static PyObject *pyop_dir(PyObject *self)
 {
        PyObject *list = PyList_New(0), *name;
        wmOperatorType *ot;
-       PyMethodDef *meth;
        
        for(ot= WM_operatortype_first(); ot; ot= ot->next) {
                name = PyUnicode_FromString(ot->idname);
                PyList_Append(list, name);
                Py_DECREF(name);
        }
-
-       for(meth=pyop_base_methods; meth->ml_name; meth++) {
-               name = PyUnicode_FromString(meth->ml_name);
-               PyList_Append(list, name);
-               Py_DECREF(name);
-       }
        
        return list;
 }
 
-static PyObject *pyop_base_rna(PyObject *self, PyObject *pyname)
+PyObject *BPY_operator_module( void )
 {
-       char *name = _PyUnicode_AsString(pyname);
-       wmOperatorType *ot;
-       
-       if ((ot= WM_operatortype_find(name, 1))) {
-               BPy_StructRNA *pyrna;
-               PointerRNA ptr;
-               
-               /* XXX POINTER - if this 'ot' is python generated, it could be free'd */
-               RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
-               
-               pyrna= (BPy_StructRNA *)pyrna_struct_CreatePyObject(&ptr); /* were not really using &ptr, overwite next */
-               //pyrna->freeptr= 1;
-               return (PyObject *)pyrna;
-       }
-       else {
-               PyErr_Format(PyExc_AttributeError, "Operator \"%s\" not found", name);
-               return NULL;
-       }
-}
+       static PyMethodDef pyop_call_meth =             {"call", (PyCFunction) pyop_call, METH_VARARGS, NULL};
+       static PyMethodDef pyop_dir_meth =              {"dir", (PyCFunction) pyop_dir, METH_NOARGS, NULL};
+       static PyMethodDef pyop_add_meth =              {"add", (PyCFunction) PYOP_wrap_add, METH_O, NULL};
+       static PyMethodDef pyop_remove_meth =   {"remove", (PyCFunction) PYOP_wrap_remove, METH_O, NULL};
 
-PyTypeObject pyop_base_Type = {NULL};
+       PyObject *submodule = PyModule_New("bpy.__ops__");
+       PyDict_SetItemString(PySys_GetObject("modules"), "bpy.__ops__", submodule);
 
-PyObject *BPY_operator_module( void )
-{
-       pyop_base_Type.tp_name = "OperatorBase";
-       pyop_base_Type.tp_basicsize = sizeof( BPy_OperatorBase );
-       pyop_base_Type.tp_getattro = ( getattrofunc )pyop_base_getattro;
-       pyop_base_Type.tp_flags = Py_TPFLAGS_DEFAULT;
-       pyop_base_Type.tp_methods = pyop_base_methods;
-       
-       if( PyType_Ready( &pyop_base_Type ) < 0 )
-               return NULL;
+       PyModule_AddObject( submodule, "call",  PyCFunction_New(&pyop_call_meth,        NULL) );
+       PyModule_AddObject( submodule, "dir",           PyCFunction_New(&pyop_dir_meth,         NULL) );
+       PyModule_AddObject( submodule, "add",           PyCFunction_New(&pyop_add_meth,         NULL) );
+       PyModule_AddObject( submodule, "remove",        PyCFunction_New(&pyop_remove_meth,      NULL) );
 
-       //submodule = Py_InitModule3( "operator", M_rna_methods, "rna module" );
-       return (PyObject *)PyObject_NEW( BPy_OperatorBase, &pyop_base_Type );
+       return submodule;
 }
-
index 9f4137a15c0cda34760bed814c750155f3796fe8..02d721739e76df993b045fcbcc3495ae14d383aa 100644 (file)
@@ -44,7 +44,8 @@
 
 #define PYOP_ATTR_PROP                 "__props__"
 #define PYOP_ATTR_UINAME               "__label__"
-#define PYOP_ATTR_IDNAME               "__name__"      /* use pythons class name */
+#define PYOP_ATTR_IDNAME               "__idname__"    /* the name given by python */
+#define PYOP_ATTR_IDNAME_BL            "__idname_bl__" /* our own name converted into blender syntax, users wont see this */
 #define PYOP_ATTR_DESCRIPTION  "__doc__"       /* use pythons docstring */
 #define PYOP_ATTR_REGISTER             "__register__"  /* True/False. if this python operator should be registered */
 
@@ -249,10 +250,9 @@ void PYTHON_OT_wrapper(wmOperatorType *ot, void *userdata)
        PyObject *props, *item;
 
        /* identifiers */
-       item= PyObject_GetAttrString(py_class, PYOP_ATTR_IDNAME);
+       item= PyObject_GetAttrString(py_class, PYOP_ATTR_IDNAME_BL);
        ot->idname= _PyUnicode_AsString(item);
        Py_DECREF(item);
-       
 
        item= PyObject_GetAttrString(py_class, PYOP_ATTR_UINAME);
        if (item) {
@@ -338,16 +338,17 @@ PyObject *PYOP_wrap_add(PyObject *self, PyObject *py_class)
        
        
        char *idname= NULL;
+       char idname_bl[OP_MAX_TYPENAME]; /* converted to blender syntax */
        int i;
 
        static struct BPY_class_attr_check pyop_class_attr_values[]= {
-               {PYOP_ATTR_IDNAME,              's', 0, 0},
-               {PYOP_ATTR_UINAME,              's', 0, BPY_CLASS_ATTR_OPTIONAL},
-               {PYOP_ATTR_PROP,                'l', 0, BPY_CLASS_ATTR_OPTIONAL},
-               {PYOP_ATTR_DESCRIPTION, 's', 0, BPY_CLASS_ATTR_NONE_OK},
-               {"execute",     'f', 2, BPY_CLASS_ATTR_OPTIONAL},
-               {"invoke",      'f', 3, BPY_CLASS_ATTR_OPTIONAL},
-               {"poll",        'f', 2, BPY_CLASS_ATTR_OPTIONAL},
+               {PYOP_ATTR_IDNAME,              's', -1, OP_MAX_TYPENAME-3,     0}, /* -3 because a.b -> A_OT_b */
+               {PYOP_ATTR_UINAME,              's', -1,-1,     BPY_CLASS_ATTR_OPTIONAL},
+               {PYOP_ATTR_PROP,                'l', -1,-1,     BPY_CLASS_ATTR_OPTIONAL},
+               {PYOP_ATTR_DESCRIPTION, 's', -1,-1,     BPY_CLASS_ATTR_NONE_OK},
+               {"execute",                             'f', 2, -1, BPY_CLASS_ATTR_OPTIONAL},
+               {"invoke",                              'f', 3, -1, BPY_CLASS_ATTR_OPTIONAL},
+               {"poll",                                'f', 2, -1, BPY_CLASS_ATTR_OPTIONAL},
                {NULL, 0, 0, 0}
        };
 
@@ -363,7 +364,18 @@ PyObject *PYOP_wrap_add(PyObject *self, PyObject *py_class)
        /* class name is used for operator ID - this can be changed later if we want */
        item= PyObject_GetAttrString(py_class, PYOP_ATTR_IDNAME);
        idname =  _PyUnicode_AsString(item);
+
+
+       /* annoying conversion! */
+       WM_operator_bl_idname(idname_bl, idname);
+       Py_DECREF(item);
+
+       item= PyUnicode_FromString(idname_bl);
+       PyObject_SetAttrString(py_class, PYOP_ATTR_IDNAME_BL, item);
+       idname =  _PyUnicode_AsString(item);
        Py_DECREF(item);
+       /* end annoying conversion! */
+
        
        /* remove if it already exists */
        if ((ot=WM_operatortype_exists(idname))) {
index d3f69e4db7320a568c96b4fcde76f797ea3c382c..bebb745a27eb7789e1f7877ed73f9bb9998bf716 100644 (file)
@@ -2550,7 +2550,7 @@ static struct PyMethodDef props_methods[] = {
 #if PY_VERSION_HEX >= 0x03000000
 static struct PyModuleDef props_module = {
        PyModuleDef_HEAD_INIT,
-       "bpyprops",
+       "bpy.props",
        "",
        -1,/* multiple "initialization" just copies the module dict. */
        props_methods,
@@ -2567,9 +2567,6 @@ PyObject *BPY_rna_props( void )
        submodule= Py_InitModule3( "bpy.props", props_methods, "" );
 #endif
        
-       mod = PyModule_New("props");
-       PyModule_AddObject( submodule, "props", mod );
-       
        /* INCREF since its its assumed that all these functions return the
         * module with a new ref like PyDict_New, since they are passed to
          * PyModule_AddObject which steals a ref */
index b451923e7801d70c8e2971ccefd0688de93d0e8a..3084cc1f8712d26aadedc9e6942423118592a8d4 100644 (file)
@@ -304,12 +304,21 @@ int BPY_class_validate(const char *class_type, PyObject *class, PyObject *base_c
                                                PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute to be a string", class_type, class_attrs->name);
                                                return -1;
                                        }
+                                       if(class_attrs->len != -1 && class_attrs->len < PyUnicode_GetSize(item)) {
+                                               PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute string to be shorter then %d", class_type, class_attrs->name, class_attrs->len);
+                                               return -1;
+                                       }
+
                                        break;
                                case 'l':
                                        if (PyList_Check(item)==0) {
                                                PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute to be a list", class_type, class_attrs->name);
                                                return -1;
                                        }
+                                       if(class_attrs->len != -1 && class_attrs->len < PyList_GET_SIZE(item)) {
+                                               PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute list to be shorter then %d", class_type, class_attrs->name, class_attrs->len);
+                                               return -1;
+                                       }
                                        break;
                                case 'f':
                                        if (PyMethod_Check(item))
index 6429af67eb0d46ae66d18cd50fbf85e271861d86..470dd4c2a45aade2bf82bcffb985570664a5d427 100644 (file)
@@ -59,6 +59,7 @@ typedef struct BPY_class_attr_check {
        const char      *name;          /* name of the class attribute */
     char               type;           /* 's' = string, 'f' = function, 'l' = list, (add as needed) */
     int                        arg_count;      /* only for function types, -1 for undefined, includes self arg */
+    int                len;            /* only for string types currently */
        int                     flag;           /* other options */
 } BPY_class_attr_check;