wip operator py-api

"operator.ED_VIEW3D_OT_viewhome(center=1)" calls the operator, converting keyword args to properties.
Need a way to run scripts in the UI for useful testing.

Still need to deal with operator exceptions and verifying args against operator options. 

Added temporary WM_operatortype_first() to allow python to return a list if available operators, can replace this with something better later (operator iterator?)

10 files changed, 629 insertions, 7 deletions

diff --git a/source/blender/python/BPY_extern.h b/source/blender/python/BPY_extern.h
index 1761ce14ed6..8561f9d1b55 100644
--- a/source/blender/python/BPY_extern.h
+++ b/source/blender/python/BPY_extern.h
@@ -94,7 +94,7 @@ extern "C" {
 	int BPY_menu_do_python( short menutype, int event );
 	int BPY_menu_do_shortcut( short menutype, unsigned short key, unsigned short modifiers );
 	int BPY_menu_invoke( struct BPyMenu *pym, short menutype );
-	void BPY_run_python_script( const char *filename );
+	void BPY_run_python_script( struct bContext *C, const char *filename );
 	int BPY_run_script(struct Script *script);
 	void BPY_free_compiled_text( struct Text *text );
 
diff --git a/source/blender/python/SConscript b/source/blender/python/SConscript
index 6190ed5c0ec..975b7a7a7e7 100644
--- a/source/blender/python/SConscript
+++ b/source/blender/python/SConscript
@@ -4,7 +4,7 @@ Import ('env')
 sources = env.Glob('intern/*.c')
 
 incs = '. ../editors/include ../makesdna ../makesrna ../blenlib ../blenkernel ../nodes'
-incs += ' ../imbuf ../blenloader ../render/extern/include'
+incs += ' ../imbuf ../blenloader ../render/extern/include ../windowmanager'
 incs += ' #intern/guardedalloc #intern/memutil'
 incs += ' ' + env['BF_PYTHON_INC']
 
diff --git a/source/blender/python/intern/bpy_idprop.c b/source/blender/python/intern/bpy_idprop.c
new file mode 100644
index 00000000000..e7e8a5fd8b5
--- /dev/null
+++ b/source/blender/python/intern/bpy_idprop.c
@@ -0,0 +1,182 @@
+/**
+ * $Id: IDProp.c
+ *
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * Contributor(s): Joseph Eagar, Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+ 
+ #include "DNA_ID.h"
+
+#include "BKE_idprop.h"
+
+#include "bpy_idprop.h"
+
+#include "MEM_guardedalloc.h"
+
+#define BSTR_EQ(a, b)	(*(a) == *(b) && !strcmp(a, b))
+
+static PyObject *EXPP_ReturnPyObjError( PyObject * type, char *error_msg )
+{				/* same as above, just to change its name smoothly */
+	PyErr_SetString( type, error_msg );
+	return NULL;
+}
+
+static int EXPP_ReturnIntError( PyObject * type, char *error_msg )
+{
+	PyErr_SetString( type, error_msg );
+	return -1;
+}
+
+ 
+/*returns NULL on success, error string on failure*/
+static char *BPy_IDProperty_Map_ValidateAndCreate(char *name, IDProperty *group, PyObject *ob)
+{
+	IDProperty *prop = NULL;
+	IDPropertyTemplate val = {0};
+	
+	if (PyFloat_Check(ob)) {
+		val.d = PyFloat_AsDouble(ob);
+		prop = IDP_New(IDP_DOUBLE, val, name);
+	} else if (PyLong_Check(ob)) {
+		val.i = (int) PyLong_AsLong(ob);
+		prop = IDP_New(IDP_INT, val, name);
+	} else if (PyUnicode_Check(ob)) {
+		val.str = _PyUnicode_AsString(ob);
+		prop = IDP_New(IDP_STRING, val, name);
+	} else if (PySequence_Check(ob)) {
+		PyObject *item;
+		int i;
+		
+		/*validate sequence and derive type.
+		we assume IDP_INT unless we hit a float
+		number; then we assume it's */
+		val.array.type = IDP_INT;
+		val.array.len = PySequence_Length(ob);
+		for (i=0; i<val.array.len; i++) {
+			item = PySequence_GetItem(ob, i);
+			if (PyFloat_Check(item)) val.array.type = IDP_DOUBLE;
+			else if (!PyLong_Check(item)) return "only floats and ints are allowed in ID property arrays";
+			Py_XDECREF(item);
+		}
+		
+		prop = IDP_New(IDP_ARRAY, val, name);
+		for (i=0; i<val.array.len; i++) {
+			item = PySequence_GetItem(ob, i);
+			if (val.array.type == IDP_INT) {
+				item = PyNumber_Int(item);
+				((int*)prop->data.pointer)[i] = (int)PyLong_AsLong(item);
+			} else {
+				item = PyNumber_Float(item);
+				((double*)prop->data.pointer)[i] = (float)PyFloat_AsDouble(item);
+			}
+			Py_XDECREF(item);
+		}
+	} else if (PyMapping_Check(ob)) {
+		PyObject *keys, *vals, *key, *pval;
+		int i, len;
+		/*yay! we get into recursive stuff now!*/
+		keys = PyMapping_Keys(ob);
+		vals = PyMapping_Values(ob);
+		
+		/*we allocate the group first; if we hit any invalid data,
+		  we can delete it easily enough.*/
+		prop = IDP_New(IDP_GROUP, val, name);
+		len = PyMapping_Length(ob);
+		for (i=0; i<len; i++) {
+			key = PySequence_GetItem(keys, i);
+			pval = PySequence_GetItem(vals, i);
+			if (!PyUnicode_Check(key)) {
+				IDP_FreeProperty(prop);
+				MEM_freeN(prop);
+				Py_XDECREF(keys);
+				Py_XDECREF(vals);
+				Py_XDECREF(key);
+				Py_XDECREF(pval);
+				return "invalid element in subgroup dict template!";
+			}
+			if (BPy_IDProperty_Map_ValidateAndCreate(_PyUnicode_AsString(key), prop, pval)) {
+				IDP_FreeProperty(prop);
+				MEM_freeN(prop);
+				Py_XDECREF(keys);
+				Py_XDECREF(vals);
+				Py_XDECREF(key);
+				Py_XDECREF(pval);
+				return "invalid element in subgroup dict template!";
+			}
+			Py_XDECREF(key);
+			Py_XDECREF(pval);
+		}
+		Py_XDECREF(keys);
+		Py_XDECREF(vals);
+	} else return "invalid property value";
+	
+	IDP_ReplaceInGroup(group, prop);
+	return NULL;
+}
+
+
+static int BPy_IDGroup_Map_SetItem(IDProperty *prop, PyObject *key, PyObject *val)
+{
+	char *err;
+	
+	if (prop->type  != IDP_GROUP)
+		return EXPP_ReturnIntError( PyExc_TypeError,
+			"unsubscriptable object");
+			
+	if (!PyUnicode_Check(key))
+		return EXPP_ReturnIntError( PyExc_TypeError,
+		   "only strings are allowed as subgroup keys" );
+
+	if (val == NULL) {
+		IDProperty *pkey = IDP_GetPropertyFromGroup(prop, _PyUnicode_AsString(key));
+		if (pkey) {
+			IDP_RemFromGroup(prop, pkey);
+			IDP_FreeProperty(pkey);
+			MEM_freeN(pkey);
+			return 0;
+		} else return EXPP_ReturnIntError( PyExc_RuntimeError, "property not found in group" );
+	}
+	
+	err = BPy_IDProperty_Map_ValidateAndCreate(_PyUnicode_AsString(key), prop, val);
+	if (err) return EXPP_ReturnIntError( PyExc_RuntimeError, err );
+	
+	return 0;
+}
+
+
+PyObject *BPy_IDGroup_Update(IDProperty *prop, PyObject *value)
+{
+	PyObject *pkey, *pval;
+	Py_ssize_t i=0;
+	
+	if (!PyDict_Check(value))
+		return EXPP_ReturnPyObjError( PyExc_TypeError,
+		   "expected an object derived from dict.");
+		   
+	while (PyDict_Next(value, &i, &pkey, &pval)) {
+		BPy_IDGroup_Map_SetItem(prop, pkey, pval);
+		if (PyErr_Occurred()) return NULL;
+	}
+	
+	Py_RETURN_NONE;
+}
\ No newline at end of file
diff --git a/source/blender/python/intern/bpy_idprop.h b/source/blender/python/intern/bpy_idprop.h
new file mode 100644
index 00000000000..c68265aca83
--- /dev/null
+++ b/source/blender/python/intern/bpy_idprop.h
@@ -0,0 +1,33 @@
+/**
+ * $Id: IDProp.h
+ *
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * Contributor(s): Joseph Eagar
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <Python.h>
+
+struct ID;
+struct IDProperty;
+
+PyObject *BPy_IDGroup_Update(IDProperty *prop, PyObject *value);
\ No newline at end of file
diff --git a/source/blender/python/intern/bpy_interface.c b/source/blender/python/intern/bpy_interface.c
index d30809ff39b..7c54c728a05 100644
--- a/source/blender/python/intern/bpy_interface.c
+++ b/source/blender/python/intern/bpy_interface.c
@@ -3,16 +3,19 @@
 #include "compile.h"		/* for the PyCodeObject */
 #include "eval.h"		/* for PyEval_EvalCode */
 
+#include "BKE_context.h"
+
 #include "bpy_compat.h"
 
 #include "bpy_rna.h"
+#include "bpy_operator.h"
 
 
 /*****************************************************************************
 * Description: This function creates a new Python dictionary object.
 *****************************************************************************/
 
-static PyObject *CreateGlobalDictionary( void )
+static PyObject *CreateGlobalDictionary( bContext *C )
 {
 	PyObject *dict = PyDict_New(  );
 	PyObject *item = PyUnicode_FromString( "__main__" );
@@ -28,6 +31,10 @@ static PyObject *CreateGlobalDictionary( void )
 	item = BPY_rna_doc();
 	PyDict_SetItemString( dict, "bpydoc", item );
 	Py_DECREF(item);
+
+	item = BPY_operator_module(C);
+	PyDict_SetItemString( dict, "bpyoperator", item );
+	Py_DECREF(item);
 	
 	return dict;
 }
@@ -60,7 +67,7 @@ static void BPY_end_python( void )
 	return;
 }
 
-void BPY_run_python_script( const char *fn )
+void BPY_run_python_script( bContext *C, const char *fn )
 {
 	PyObject *py_dict, *py_result;
 	char pystring[512];
@@ -73,7 +80,7 @@ void BPY_run_python_script( const char *fn )
 	
 	gilstate = PyGILState_Ensure();
 	
-	py_dict = CreateGlobalDictionary();
+	py_dict = CreateGlobalDictionary(C);
 	
 	py_result = PyRun_String( pystring, Py_file_input, py_dict, py_dict );
 	
diff --git a/source/blender/python/intern/bpy_operator.c b/source/blender/python/intern/bpy_operator.c
new file mode 100644
index 00000000000..85badf18bb7
--- /dev/null
+++ b/source/blender/python/intern/bpy_operator.c
@@ -0,0 +1,340 @@
+
+/**
+ * $Id$
+ *
+ * ***** 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.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "bpy_operator.h"
+#include "bpy_compat.h"
+#include "bpy_idprop.h"
+
+//#include "blendef.h"
+#include "BLI_dynstr.h"
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "MEM_guardedalloc.h"
+#include "BKE_idprop.h"
+
+extern ListBase global_ops; /* evil, temp use */
+
+/* floats bigger then this are displayed as inf in the docstrings */
+#define MAXFLOAT_DOC 10000000
+
+static int pyop_func_compare( BPy_OperatorFunc * a, BPy_OperatorFunc * b )
+{
+	return (strcmp(a->name, b->name)==0) ? 0 : -1;
+}
+
+/*----------------------repr--------------------------------------------*/
+static PyObject *pyop_base_repr( BPy_OperatorBase * self )
+{
+	return PyUnicode_FromFormat( "[BPy_OperatorBase]");
+}
+
+static PyObject *pyop_func_repr( BPy_OperatorFunc * self )
+{
+	return PyUnicode_FromFormat( "[BPy_OperatorFunc \"%s\"]", self->name);
+}
+
+//---------------getattr--------------------------------------------
+static PyObject *pyop_base_getattro( BPy_OperatorBase * self, PyObject *pyname )
+{
+	char *name = _PyUnicode_AsString(pyname);
+	PyObject *ret;
+	wmOperatorType *ot;
+
+	if( strcmp( name, "__members__" ) == 0 ) {
+		PyObject *item;
+
+		ret = PyList_New(0);
+
+		for(ot= WM_operatortype_first(); ot; ot= ot->next) {
+			item = PyUnicode_FromString( ot->idname );
+			PyList_Append(ret, item);
+			Py_DECREF(item);
+		}
+	} else {
+		ot = WM_operatortype_find(name);
+
+		if (ot) {
+			return pyop_func_CreatePyObject(self->C, name);
+		}
+		else {
+			PyErr_Format( PyExc_AttributeError, "Operator \"%s\" not found", name);
+		}
+	}
+	
+	return ret;
+}
+
+static PyObject * pyop_func_call(BPy_OperatorFunc * self, PyObject *args, PyObject *kw)
+{
+	IDProperty *properties = NULL;
+
+	if (PyTuple_Size(args)) {
+		PyErr_SetString( PyExc_AttributeError, "All operator args must be keywords");
+		return NULL;
+	}
+
+	if (kw && PyDict_Size(kw) > 0) {
+		IDPropertyTemplate val;
+		val.i = 0; /* silence MSVC warning about uninitialized var when debugging */
+
+		properties= IDP_New(IDP_GROUP, val, "property");
+		BPy_IDGroup_Update(properties, kw);
+
+		if (PyErr_Occurred()) {
+			IDP_FreeProperty(properties);
+			MEM_freeN(properties);
+			return NULL;
+		}
+	}
+	
+	WM_operator_call(self->C, self->name, WM_OP_DEFAULT, properties);
+
+	if (properties) {
+		IDP_FreeProperty(properties);
+		MEM_freeN(properties);
+	}
+	Py_RETURN_NONE;
+}
+
+/*-----------------------BPy_OperatorBase method def------------------------------*/
+PyTypeObject pyop_base_Type = {
+#if (PY_VERSION_HEX >= 0x02060000)
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else
+	/* python 2.5 and below */
+	PyObject_HEAD_INIT( NULL )  /* required py macro */
+	0,                          /* ob_size */
+#endif
+
+	"Operator",		/* tp_name */
+	sizeof( BPy_OperatorBase ),			/* tp_basicsize */
+	0,			/* tp_itemsize */
+	/* methods */
+	NULL,						/* tp_dealloc */
+	NULL,                       /* printfunc tp_print; */
+	NULL,						/* getattrfunc tp_getattr; */
+	NULL,                       /* setattrfunc tp_setattr; */
+	NULL,						/* tp_compare */
+	( reprfunc ) pyop_base_repr,	/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,						/* PySequenceMethods *tp_as_sequence; */
+	NULL,						/* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	( getattrofunc )pyop_base_getattro, /*PyObject_GenericGetAttr - MINGW Complains, assign later */	/* getattrofunc tp_getattro; */
+	NULL, /*PyObject_GenericSetAttr - MINGW Complains, assign later */	/* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT,         /* long tp_flags; */
+
+	NULL,						/*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,						/* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,						/* struct PyMethodDef *tp_methods; */
+	NULL,                       /* struct PyMemberDef *tp_members; */
+	NULL,      					/* struct PyGetSetDef *tp_getset; */
+	NULL,                       /* struct _typeobject *tp_base; */
+	NULL,                       /* PyObject *tp_dict; */
+	NULL,                       /* descrgetfunc tp_descr_get; */
+	NULL,                       /* descrsetfunc tp_descr_set; */
+	0,                          /* long tp_dictoffset; */
+	NULL,                       /* initproc tp_init; */
+	NULL,                       /* allocfunc tp_alloc; */
+	NULL,						/* newfunc tp_new; */
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+/*-----------------------BPy_OperatorBase method def------------------------------*/
+PyTypeObject pyop_func_Type = {
+#if (PY_VERSION_HEX >= 0x02060000)
+	PyVarObject_HEAD_INIT(&PyType_Type, 0)
+#else
+	/* python 2.5 and below */
+	PyObject_HEAD_INIT( NULL )  /* required py macro */
+	0,                          /* ob_size */
+#endif
+
+	"OperatorFunc",		/* tp_name */
+	sizeof( BPy_OperatorFunc ),			/* tp_basicsize */
+	0,			/* tp_itemsize */
+	/* methods */
+	NULL,						/* tp_dealloc */
+	NULL,                       /* printfunc tp_print; */
+	NULL,						/* getattrfunc tp_getattr; */
+	NULL,                       /* setattrfunc tp_setattr; */
+	( cmpfunc ) pyop_func_compare,	/* tp_compare */
+	( reprfunc ) pyop_func_repr,	/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,						/* PySequenceMethods *tp_as_sequence; */
+	NULL,						/* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	(ternaryfunc)pyop_func_call,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL, /*PyObject_GenericGetAttr - MINGW Complains, assign later */	/* getattrofunc tp_getattro; */
+	NULL, /*PyObject_GenericSetAttr - MINGW Complains, assign later */	/* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT,         /* long tp_flags; */
+
+	NULL,						/*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,						/* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,						/* struct PyMethodDef *tp_methods; */
+	NULL,                       /* struct PyMemberDef *tp_members; */
+	NULL,      					/* struct PyGetSetDef *tp_getset; */
+	NULL,                       /* struct _typeobject *tp_base; */
+	NULL,                       /* PyObject *tp_dict; */
+	NULL,                       /* descrgetfunc tp_descr_get; */
+	NULL,                       /* descrsetfunc tp_descr_set; */
+	0,                          /* long tp_dictoffset; */
+	NULL,                       /* initproc tp_init; */
+	NULL,                       /* allocfunc tp_alloc; */
+	NULL,						/* newfunc tp_new; */
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+PyObject *pyop_base_CreatePyObject( bContext *C )
+{
+	BPy_OperatorBase *pyop;
+
+	pyop = ( BPy_OperatorBase * ) PyObject_NEW( BPy_OperatorBase, &pyop_base_Type );
+
+	if( !pyop ) {
+		PyErr_SetString( PyExc_MemoryError, "couldn't create BPy_OperatorBase object" );
+		return NULL;
+	}
+
+	pyop->C = C; /* TODO - copy this? */
+
+	return ( PyObject * ) pyop;
+}
+
+PyObject *pyop_func_CreatePyObject( bContext *C, char *name )
+{
+	BPy_OperatorFunc *pyop;
+
+	pyop = ( BPy_OperatorFunc * ) PyObject_NEW( BPy_OperatorFunc, &pyop_func_Type );
+
+	if( !pyop ) {
+		PyErr_SetString( PyExc_MemoryError, "couldn't create BPy_OperatorFunc object" );
+		return NULL;
+	}
+
+	strcpy(pyop->name, name);
+	pyop->C= C; /* TODO - how should contexts be dealt with? */
+
+	return ( PyObject * ) pyop;
+}
+
+PyObject *BPY_operator_module( bContext *C )
+{
+	if( PyType_Ready( &pyop_base_Type ) < 0 )
+		return NULL;
+
+	if( PyType_Ready( &pyop_func_Type ) < 0 )
+		return NULL;
+
+	//submodule = Py_InitModule3( "operator", M_rna_methods, "rna module" );
+	return pyop_base_CreatePyObject(C);
+}
+
+
+
diff --git a/source/blender/python/intern/bpy_operator.h b/source/blender/python/intern/bpy_operator.h
new file mode 100644
index 00000000000..55797f6d8cc
--- /dev/null
+++ b/source/blender/python/intern/bpy_operator.h
@@ -0,0 +1,54 @@
+
+/**
+ * $Id$
+ *
+ * ***** 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.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef BPY_OPERATOR_H
+#define BPY_OPERATOR_H
+
+#include <Python.h>
+
+#include "RNA_access.h"
+#include "RNA_types.h"
+#include "DNA_windowmanager_types.h"
+#include "BKE_context.h"
+
+extern PyTypeObject pyop_base_Type;
+extern PyTypeObject pyop_func_Type;
+
+typedef struct {
+	PyObject_VAR_HEAD /* required python macro   */
+	bContext *C;
+} BPy_OperatorBase;
+
+typedef struct {
+	PyObject_VAR_HEAD /* required python macro   */
+	char name[OP_MAX_TYPENAME];
+	bContext *C;
+} BPy_OperatorFunc;
+
+PyObject *BPY_operator_module(bContext *C );
+
+PyObject *pyop_base_CreatePyObject(bContext *C );
+PyObject *pyop_func_CreatePyObject(bContext *C, char *name );
+
+#endif
diff --git a/source/blender/windowmanager/WM_api.h b/source/blender/windowmanager/WM_api.h
index 19ddd43f7ec..b1209af9afe 100644
--- a/source/blender/windowmanager/WM_api.h
+++ b/source/blender/windowmanager/WM_api.h
@@ -114,6 +114,7 @@ void		WM_error(struct bContext *C, char *str);
 
 			/* operator api */
 wmOperatorType *WM_operatortype_find(const char *idname);
+wmOperatorType *WM_operatortype_first(void);
 void		WM_operatortype_append	(void (*opfunc)(wmOperatorType*));
 
 int         WM_operator_call		(struct bContext *C, const char *opstring, int context, struct IDProperty *properties);
diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c
index d69b0901bc6..11f6f8fa93a 100644
--- a/source/blender/windowmanager/intern/wm_operators.c
+++ b/source/blender/windowmanager/intern/wm_operators.c
@@ -77,6 +77,11 @@ wmOperatorType *WM_operatortype_find(const char *idname)
 	return NULL;
 }
 
+wmOperatorType *WM_operatortype_first(void)
+{
+	return global_ops.first;
+}
+
 /* all ops in 1 list (for time being... needs evaluation later) */
 void WM_operatortype_append(void (*opfunc)(wmOperatorType*))
 {
diff --git a/source/creator/creator.c b/source/creator/creator.c
index 471ea6bbe5b..5c10b0c346c 100644
--- a/source/creator/creator.c
+++ b/source/creator/creator.c
@@ -679,7 +679,7 @@ int main(int argc, char **argv)
 				//XXX 
 				// FOR TESTING ONLY
 				a++;
-				BPY_run_python_script (argv[a]);
+				BPY_run_python_script(C, argv[a]);
 #if 0
 				a++;
 				if (a < argc) {
@@ -688,7 +688,7 @@ int main(int argc, char **argv)
 						main_init_screen();
 						scr_init = 1;
 					}
-					BPY_run_python_script (argv[a]);
+					BPY_run_python_script(C, argv[a]);
 				}
 				else printf("\nError: you must specify a Python script after '-P '.\n");
 #endif