def main():
import rna_info
struct = rna_info.BuildRNAInfo()[0]
data = []
for struct_id, v in sorted(struct.items()):
struct_id_str = v.identifier # "".join(sid for sid in struct_id if struct_id)
for base in v.get_bases():
struct_id_str = base.identifier + "|" + struct_id_str
props = [(prop.identifier, prop) for prop in v.properties]
for prop_id, prop in sorted(props):
# if prop.type == "boolean":
# continue
prop_type = prop.type
if prop.array_length > 0:
prop_type += "[%d]" % prop.array_length
data.append(
"%s.%s -> %s: %s%s %s" %
(struct_id_str, prop.identifier, prop.identifier, prop_type,
", (read-only)" if prop.is_readonly else "",
prop.description))
data.sort()
if bpy.app.background:
import sys
sys.stderr.write("\n".join(data))
sys.stderr.write("\n\nEOF\n")
else:
text = bpy.data.texts.new(name="api.py")
text.from_string(data)
def rna_ids():
import rna_info
struct = rna_info.BuildRNAInfo()[0]
for struct_id, v in sorted(struct.items()):
props = [(prop.identifier, prop) for prop in v.properties]
struct_path = "bpy.types.%s" % struct_id[1]
for prop_id, prop in props:
yield (struct_path, "%s.%s" % (struct_path, prop_id))
for submod_id in dir(bpy.ops):
op_path = "bpy.ops.%s" % submod_id
for op_id in dir(getattr(bpy.ops, submod_id)):
yield (op_path, "%s.%s" % (op_path, op_id))
def check_duplicates():
import rna_info
DUPLICATE_IGNORE_FOUND = set()
DUPLICATE_WHITELIST_FOUND = set()
structs, funcs, ops, props = rna_info.BuildRNAInfo()
# This is mainly useful for operators,
# other types have too many false positives
# for t in (structs, funcs, ops, props):
for t in (ops, ):
description_dict = {}
print("")
for k, v in t.items():
if v.description not in DUPLICATE_IGNORE:
id_str = ".".join([
s if isinstance(s, str) else s.identifier for s in k if s
])
description_dict.setdefault(v.description, []).append(id_str)
else:
DUPLICATE_IGNORE_FOUND.add(v.description)
# sort for easier viewing
sort_ls = [(tuple(sorted(v)), k) for k, v in description_dict.items()]
sort_ls.sort()
for v, k in sort_ls:
if len(v) > 1:
if v not in DUPLICATE_WHITELIST:
print("found %d: %r, \"%s\"" % (len(v), v, k))
#print("%r," % (v,))
else:
DUPLICATE_WHITELIST_FOUND.add(v)
test = (DUPLICATE_IGNORE - DUPLICATE_IGNORE_FOUND)
if test:
print("Invalid 'DUPLICATE_IGNORE': %r" % test)
test = (set(DUPLICATE_WHITELIST) - DUPLICATE_WHITELIST_FOUND)
if test:
print("Invalid 'DUPLICATE_WHITELIST': %r" % test)
def bpy2predef(BASEPATH, title):
''' Creates the bpy.predef file. It contains the bpy.dta, bpy.ops, bpy.types
Arguments:
BASEPATH (string): path for the output file
title(string): descriptive title (the comment for the whole module)
'''
def property2predef(ident, fw, module, name):
''' writes definition of a named property
Details:
@ident (string): the required prefix (spaces)
@fw (function): the unified shortcut to print() or file.write() function
@module (string): one of bpy.ops names ("actions", for example)
@name (string): name of the property
'''
value = getattr(module, name, None)
if value:
value_type = getattr(value, "rna_type", None)
if value_type:
fw("{0} = types.{1}\n".format(name, value_type.identifier))
else:
pyclass2predef(fw, modulr, name, value)
fw("\n\n")
#read all data:
structs, funcs, ops, props = rna_info.BuildRNAInfo()
#open the file:
filepath = os.path.join(BASEPATH, "bpy.py")
file = open(filepath, "w")
fw = file.write
#Start the file:
definition = doc2definition(title,"") #skip the leading spaces at the first line...
fw(definition["docstring"])
fw("\n\n")
#group operators by modules: (dictionary of list of the operators)
op_modules = {}
for op in ops.values():
op_modules.setdefault(op.module_name, []).append(op)
#Special declaration of non-existing structiure just fo the ops member:
fw("class ops:\n")
fw(_IDENT+"'''Spcecial class, created just to reflect content of bpy.ops'''\n\n")
for op_module_name, ops_mod in sorted(op_modules.items(),key = lambda m : m[0]):
if op_module_name == "import":
continue
ops_struct2predef(_IDENT, fw, op_module_name, ops_mod)
#classes (Blender structures:)
fw("class types:\n")
fw(_IDENT+"'''A container for all Blender types'''\n" + _IDENT + "\n")
#base structure
bpy_base2predef(_IDENT, fw)
#sort the type names:
classes = list(structs.values())
classes.sort(key=lambda cls: cls.identifier)
for cls in classes:
# skip the operators!
if "_OT_" not in cls.identifier:
rna_struct2predef(_IDENT, fw, cls)
#the data members:
property2predef("", fw, bpy, "context")
property2predef("", fw, bpy, "data")
file.close()
def api_dump(args):
import rna_info
import inspect
version, version_key = api_version()
if version is None:
raise(ValueError("API dumps can only be generated from within Blender."))
dump = {}
dump_module = dump["bpy.types"] = {}
struct = rna_info.BuildRNAInfo()[0]
for struct_id, struct_info in sorted(struct.items()):
struct_id_str = struct_info.identifier
if rna_info.rna_id_ignore(struct_id_str):
continue
for base in struct_info.get_bases():
struct_id_str = base.identifier + "." + struct_id_str
dump_class = dump_module[struct_id_str] = {}
props = [(prop.identifier, prop) for prop in struct_info.properties]
for prop_id, prop in sorted(props):
# if prop.type == 'boolean':
# continue
prop_type = prop.type
prop_length = prop.array_length
prop_range = round(prop.min, 4), round(prop.max, 4)
prop_default = prop.default
if type(prop_default) is float:
prop_default = round(prop_default, 4)
if prop_range[0] == -1 and prop_range[1] == -1:
prop_range = None
dump_class[prop_id] = (
"prop_rna", # basic_type
prop.name, # name
prop_type, # type
prop_range, # range
prop_length, # length
prop.default, # default
prop.description, # descr
Ellipsis, # f_args
Ellipsis, # f_arg_types
Ellipsis, # f_ret_types
)
del props
# python props, tricky since we don't know much about them.
for prop_id, attr in struct_info.get_py_properties():
dump_class[prop_id] = (
"prop_py", # basic_type
Ellipsis, # name
Ellipsis, # type
Ellipsis, # range
Ellipsis, # length
Ellipsis, # default
attr.__doc__, # descr
Ellipsis, # f_args
Ellipsis, # f_arg_types
Ellipsis, # f_ret_types
)
# kludge func -> props
funcs = [(func.identifier, func) for func in struct_info.functions]
for func_id, func in funcs:
func_ret_types = tuple([prop.type for prop in func.return_values])
func_args_ids = tuple([prop.identifier for prop in func.args])
func_args_type = tuple([prop.type for prop in func.args])
dump_class[func_id] = (
"func_rna", # basic_type
Ellipsis, # name
Ellipsis, # type
Ellipsis, # range
Ellipsis, # length
Ellipsis, # default
func.description, # descr
func_args_ids, # f_args
func_args_type, # f_arg_types
func_ret_types, # f_ret_types
)
del funcs
# kludge func -> props
funcs = struct_info.get_py_functions()
for func_id, attr in funcs:
# arg_str = inspect.formatargspec(*inspect.getargspec(py_func))
sig = inspect.signature(attr)
func_args_ids = [k for k, v in sig.parameters.items()]
dump_class[func_id] = (
"func_py", # basic_type
Ellipsis, # name
Ellipsis, # type
Ellipsis, # range
Ellipsis, # length
Ellipsis, # default
attr.__doc__, # descr
func_args_ids, # f_args
Ellipsis, # f_arg_types
Ellipsis, # f_ret_types
)
del funcs
filepath_out = args.filepath_out
with open(filepath_out, 'w', encoding='utf-8') as file_handle:
json.dump((version, dump), file_handle, cls=JSONEncoderAPIDump)
indexpath = args.indexpath
rootpath = os.path.dirname(indexpath)
if os.path.exists(indexpath):
with open(indexpath, 'r', encoding='utf-8') as file_handle:
index = json.load(file_handle)
else:
index = {}
index[version_key] = os.path.relpath(filepath_out, rootpath)
with open(indexpath, 'w', encoding='utf-8') as file_handle:
json.dump(index, file_handle)
print("API version %s dumped into %r, and index %r has been updated" % (version_key, filepath_out, indexpath))
def api_dump(use_properties=True, use_functions=True):
def prop_type(prop):
if prop.type == "pointer":
return prop.fixed_type.identifier
else:
return prop.type
def func_to_str(struct_id_str, func_id, func):
args = []
for prop in func.args:
data_str = "%s %s" % (prop_type(prop), prop.identifier)
if prop.array_length:
data_str += "[%d]" % prop.array_length
if not prop.is_required:
data_str += "=%s" % prop.default_str
args.append(data_str)
data_str = "%s.%s(%s)" % (struct_id_str, func_id, ", ".join(args))
if func.return_values:
return_args = ", ".join(
prop_type(arg) for arg in func.return_values)
if len(func.return_values) > 1:
data_str += " --> (%s)" % return_args
else:
data_str += " --> %s" % return_args
return data_str
def prop_to_str(struct_id_str, prop_id, prop):
prop_str = " <-- %s" % prop_type(prop)
if prop.array_length:
prop_str += "[%d]" % prop.array_length
data_str = "%s.%s %s" % (struct_id_str, prop_id, prop_str)
return data_str
def struct_full_id(v):
struct_id_str = v.identifier # "".join(sid for sid in struct_id if struct_id)
for base in v.get_bases():
struct_id_str = base.identifier + "|" + struct_id_str
return struct_id_str
def dump_funcs():
data = []
for struct_id, v in sorted(struct.items()):
struct_id_str = struct_full_id(v)
funcs = [(func.identifier, func) for func in v.functions]
for func_id, func in funcs:
data.append(func_to_str(struct_id_str, func_id, func))
for prop in v.properties:
if prop.collection_type:
funcs = [(prop.identifier + "." + func.identifier, func)
for func in prop.collection_type.functions]
for func_id, func in funcs:
data.append(func_to_str(struct_id_str, func_id, func))
data.sort()
data.append("# * functions *")
return data
def dump_props():
data = []
for struct_id, v in sorted(struct.items()):
struct_id_str = struct_full_id(v)
props = [(prop.identifier, prop) for prop in v.properties]
for prop_id, prop in props:
data.append(prop_to_str(struct_id_str, prop_id, prop))
for prop in v.properties:
if prop.collection_type:
props = [(prop.identifier + "." + prop_sub.identifier,
prop_sub)
for prop_sub in prop.collection_type.properties]
for prop_sub_id, prop_sub in props:
data.append(
prop_to_str(struct_id_str, prop_sub_id, prop_sub))
data.sort()
data.insert(0, "# * properties *")
return data
import rna_info
struct = rna_info.BuildRNAInfo()[0]
data = []
if use_functions:
data.extend(dump_funcs())
if use_properties:
data.extend(dump_props())
if bpy.app.background:
import sys
sys.stderr.write("\n".join(data))
sys.stderr.write("\n\nEOF\n")
else:
text = bpy.data.texts.new(name="api.py")
text.from_string(data)
print("END")
def pyrna2sphinx(BASEPATH):
""" bpy.types and bpy.ops
"""
structs, funcs, ops, props = rna_info.BuildRNAInfo()
if FILTER_BPY_TYPES is not None:
structs = {
k: v
for k, v in structs.items() if k[1] in FILTER_BPY_TYPES
}
if FILTER_BPY_OPS is not None:
ops = {k: v for k, v in ops.items() if v.module_name in FILTER_BPY_OPS}
def write_param(ident, fw, prop, is_return=False):
if is_return:
id_name = "return"
id_type = "rtype"
kwargs = {"as_ret": True}
identifier = ""
else:
id_name = "arg"
id_type = "type"
kwargs = {"as_arg": True}
identifier = " %s" % prop.identifier
kwargs["class_fmt"] = ":class:`%s`"
kwargs["collection_id"] = _BPY_PROP_COLLECTION_ID
type_descr = prop.get_type_description(**kwargs)
enum_text = pyrna_enum2sphinx(prop)
if prop.name or prop.description or enum_text:
fw(ident + ":%s%s:\n\n" % (id_name, identifier))
if prop.name or prop.description:
fw(ident + " " +
", ".join(val
for val in (prop.name, prop.description) if val) +
"\n\n")
# special exception, cant use genric code here for enums
if enum_text:
write_indented_lines(ident + " ", fw, enum_text)
fw("\n")
del enum_text
# end enum exception
fw(ident + ":%s%s: %s\n" % (id_type, identifier, type_descr))
def write_struct(struct):
#if not struct.identifier.startswith("Sc") and not struct.identifier.startswith("I"):
# return
#if not struct.identifier == "Object":
# return
filepath = os.path.join(BASEPATH,
"bpy.types.%s.rst" % struct.identifier)
file = open(filepath, "w")
fw = file.write
base_id = getattr(struct.base, "identifier", "")
if _BPY_STRUCT_FAKE:
if not base_id:
base_id = _BPY_STRUCT_FAKE
if base_id:
title = "%s(%s)" % (struct.identifier, base_id)
else:
title = struct.identifier
write_title(fw, title, "=")
fw(".. module:: bpy.types\n\n")
# docs first?, ok
write_example_ref("", fw, "bpy.types.%s" % struct.identifier)
base_ids = [base.identifier for base in struct.get_bases()]
if _BPY_STRUCT_FAKE:
base_ids.append(_BPY_STRUCT_FAKE)
base_ids.reverse()
if base_ids:
if len(base_ids) > 1:
fw("base classes --- ")
else:
fw("base class --- ")
fw(", ".join((":class:`%s`" % base_id) for base_id in base_ids))
fw("\n\n")
subclass_ids = [
s.identifier for s in structs.values() if s.base is struct
if not rna_info.rna_id_ignore(s.identifier)
]
if subclass_ids:
fw("subclasses --- \n" + ", ".join(
(":class:`%s`" % s) for s in subclass_ids) + "\n\n")
base_id = getattr(struct.base, "identifier", "")
if _BPY_STRUCT_FAKE:
if not base_id:
base_id = _BPY_STRUCT_FAKE
if base_id:
fw(".. class:: %s(%s)\n\n" % (struct.identifier, base_id))
else:
fw(".. class:: %s\n\n" % struct.identifier)
fw(" %s\n\n" % struct.description)
# properties sorted in alphabetical order
sorted_struct_properties = struct.properties[:]
sorted_struct_properties.sort(key=lambda prop: prop.identifier)
for prop in sorted_struct_properties:
type_descr = prop.get_type_description(
class_fmt=":class:`%s`", collection_id=_BPY_PROP_COLLECTION_ID)
# readonly properties use "data" directive, variables properties use "attribute" directive
if 'readonly' in type_descr:
fw(" .. data:: %s\n\n" % prop.identifier)
else:
fw(" .. attribute:: %s\n\n" % prop.identifier)
if prop.description:
fw(" %s\n\n" % prop.description)
# special exception, cant use genric code here for enums
if prop.type == "enum":
enum_text = pyrna_enum2sphinx(prop)
if enum_text:
write_indented_lines(" ", fw, enum_text)
fw("\n")
del enum_text
# end enum exception
fw(" :type: %s\n\n" % type_descr)
# python attributes
py_properties = struct.get_py_properties()
py_prop = None
for identifier, py_prop in py_properties:
pyprop2sphinx(" ", fw, identifier, py_prop)
del py_properties, py_prop
for func in struct.functions:
args_str = ", ".join(
prop.get_arg_default(force=False) for prop in func.args)
fw(" .. %s:: %s(%s)\n\n" %
("classmethod" if func.is_classmethod else "method",
func.identifier, args_str))
fw(" %s\n\n" % func.description)
for prop in func.args:
write_param(" ", fw, prop)
if len(func.return_values) == 1:
write_param(" ",
fw,
func.return_values[0],
is_return=True)
elif func.return_values: # multiple return values
fw(" :return (%s):\n" %
", ".join(prop.identifier for prop in func.return_values))
for prop in func.return_values:
# TODO, pyrna_enum2sphinx for multiple return values... actually dont think we even use this but still!!!
type_descr = prop.get_type_description(
as_ret=True,
class_fmt=":class:`%s`",
collection_id=_BPY_PROP_COLLECTION_ID)
descr = prop.description
if not descr:
descr = prop.name
fw(" `%s`, %s, %s\n\n" %
(prop.identifier, descr, type_descr))
write_example_ref(
" ", fw,
"bpy.types." + struct.identifier + "." + func.identifier)
fw("\n")
# python methods
py_funcs = struct.get_py_functions()
py_func = None
for identifier, py_func in py_funcs:
pyfunc2sphinx(" ", fw, identifier, py_func, is_class=True)
del py_funcs, py_func
py_funcs = struct.get_py_c_functions()
py_func = None
for identifier, py_func in py_funcs:
py_c_func2sphinx(" ",
fw,
"bpy.types",
struct.identifier,
identifier,
py_func,
is_class=True)
lines = []
if struct.base or _BPY_STRUCT_FAKE:
bases = list(reversed(struct.get_bases()))
# props
lines[:] = []
if _BPY_STRUCT_FAKE:
descr_items = [(key, descr) for key, descr in sorted(
bpy.types.Struct.__bases__[0].__dict__.items())
if not key.startswith("__")]
if _BPY_STRUCT_FAKE:
for key, descr in descr_items:
if type(descr) == GetSetDescriptorType:
lines.append(" * :class:`%s.%s`\n" %
(_BPY_STRUCT_FAKE, key))
for base in bases:
for prop in base.properties:
lines.append(" * :class:`%s.%s`\n" %
(base.identifier, prop.identifier))
for identifier, py_prop in base.get_py_properties():
lines.append(" * :class:`%s.%s`\n" %
(base.identifier, identifier))
for identifier, py_prop in base.get_py_properties():
lines.append(" * :class:`%s.%s`\n" %
(base.identifier, identifier))
if lines:
fw(".. rubric:: Inherited Properties\n\n")
fw(".. hlist::\n")
fw(" :columns: 2\n\n")
for line in lines:
fw(line)
fw("\n")
# funcs
lines[:] = []
if _BPY_STRUCT_FAKE:
for key, descr in descr_items:
if type(descr) == MethodDescriptorType:
lines.append(" * :class:`%s.%s`\n" %
(_BPY_STRUCT_FAKE, key))
for base in bases:
for func in base.functions:
lines.append(" * :class:`%s.%s`\n" %
(base.identifier, func.identifier))
for identifier, py_func in base.get_py_functions():
lines.append(" * :class:`%s.%s`\n" %
(base.identifier, identifier))
if lines:
fw(".. rubric:: Inherited Functions\n\n")
fw(".. hlist::\n")
fw(" :columns: 2\n\n")
for line in lines:
fw(line)
fw("\n")
lines[:] = []
if struct.references:
# use this otherwise it gets in the index for a normal heading.
fw(".. rubric:: References\n\n")
fw(".. hlist::\n")
fw(" :columns: 2\n\n")
for ref in struct.references:
ref_split = ref.split(".")
if len(ref_split) > 2:
ref = ref_split[-2] + "." + ref_split[-1]
fw(" * :class:`%s`\n" % ref)
fw("\n")
# docs last?, disable for now
# write_example_ref("", fw, "bpy.types.%s" % struct.identifier)
file.close()
if "bpy.types" not in EXCLUDE_MODULES:
for struct in structs.values():
# TODO, rna_info should filter these out!
if "_OT_" in struct.identifier:
continue
write_struct(struct)
def fake_bpy_type(class_value,
class_name,
descr_str,
use_subclasses=True):
filepath = os.path.join(BASEPATH, "bpy.types.%s.rst" % class_name)
file = open(filepath, "w")
fw = file.write
write_title(fw, class_name, "=")
fw(".. module:: bpy.types\n")
fw("\n")
if use_subclasses:
subclass_ids = [
s.identifier for s in structs.values() if s.base is None
if not rna_info.rna_id_ignore(s.identifier)
]
if subclass_ids:
fw("subclasses --- \n" + ", ".join(
(":class:`%s`" % s)
for s in sorted(subclass_ids)) + "\n\n")
fw(".. class:: %s\n\n" % class_name)
fw(" %s\n\n" % descr_str)
fw(" .. note::\n\n")
fw(" Note that bpy.types.%s is not actually available from within blender, it only exists for the purpose of documentation.\n\n"
% class_name)
descr_items = [
(key, descr)
for key, descr in sorted(class_value.__dict__.items())
if not key.startswith("__")
]
for key, descr in descr_items:
if type(
descr
) == MethodDescriptorType: # GetSetDescriptorType, GetSetDescriptorType's are not documented yet
py_descr2sphinx(" ", fw, descr, "bpy.types", class_name,
key)
for key, descr in descr_items:
if type(descr) == GetSetDescriptorType:
py_descr2sphinx(" ", fw, descr, "bpy.types", class_name,
key)
file.close()
# write fake classes
if _BPY_STRUCT_FAKE:
class_value = bpy.types.Struct.__bases__[0]
fake_bpy_type(class_value,
_BPY_STRUCT_FAKE,
"built-in base class for all classes in bpy.types.",
use_subclasses=True)
if _BPY_PROP_COLLECTION_FAKE:
class_value = bpy.data.objects.__class__
fake_bpy_type(class_value,
_BPY_PROP_COLLECTION_FAKE,
"built-in class used for all collections.",
use_subclasses=False)
# operators
def write_ops():
API_BASEURL = "http://svn.blender.org/svnroot/bf-blender/trunk/blender/release/scripts"
API_BASEURL_ADDON = "http://svn.blender.org/svnroot/bf-extensions/trunk/py/scripts"
API_BASEURL_ADDON_CONTRIB = "http://svn.blender.org/svnroot/bf-extensions/contrib/py/scripts"
op_modules = {}
for op in ops.values():
op_modules.setdefault(op.module_name, []).append(op)
del op
for op_module_name, ops_mod in op_modules.items():
filepath = os.path.join(BASEPATH,
"bpy.ops.%s.rst" % op_module_name)
file = open(filepath, "w")
fw = file.write
title = "%s Operators" % op_module_name.replace("_", " ").title()
write_title(fw, title, "=")
fw(".. module:: bpy.ops.%s\n\n" % op_module_name)
ops_mod.sort(key=lambda op: op.func_name)
for op in ops_mod:
args_str = ", ".join(
prop.get_arg_default(force=True) for prop in op.args)
fw(".. function:: %s(%s)\n\n" % (op.func_name, args_str))
# if the description isn't valid, we output the standard warning
# with a link to the wiki so that people can help
if not op.description or op.description == "(undocumented operator)":
operator_description = undocumented_message(
'bpy.ops', op.module_name, op.func_name)
else:
operator_description = op.description
fw(" %s\n\n" % operator_description)
for prop in op.args:
write_param(" ", fw, prop)
if op.args:
fw("\n")
location = op.get_location()
if location != (None, None):
if location[0].startswith("addons_contrib" + os.sep):
url_base = API_BASEURL_ADDON_CONTRIB
elif location[0].startswith("addons" + os.sep):
url_base = API_BASEURL_ADDON
else:
url_base = API_BASEURL
fw(" :file: `%s <%s/%s>`_:%d\n\n" %
(location[0], url_base, location[0], location[1]))
file.close()
if "bpy.ops" not in EXCLUDE_MODULES:
write_ops()
def api_dump():
dump = {}
dump_module = dump["bpy.types"] = {}
import rna_info
import inspect
struct = rna_info.BuildRNAInfo()[0]
for struct_id, struct_info in sorted(struct.items()):
struct_id_str = struct_info.identifier
if rna_info.rna_id_ignore(struct_id_str):
continue
for base in struct_info.get_bases():
struct_id_str = base.identifier + "." + struct_id_str
dump_class = dump_module[struct_id_str] = {}
props = [(prop.identifier, prop) for prop in struct_info.properties]
for prop_id, prop in sorted(props):
# if prop.type == 'boolean':
# continue
prop_type = prop.type
prop_length = prop.array_length
prop_range = round(prop.min, 4), round(prop.max, 4)
prop_default = prop.default
if type(prop_default) is float:
prop_default = round(prop_default, 4)
if prop_range[0] == -1 and prop_range[1] == -1:
prop_range = None
dump_class[prop_id] = (
"prop_rna", # basic_type
prop.name, # name
prop_type, # type
prop_range, # range
prop_length, # length
prop.default, # default
prop.description, # descr
Ellipsis, # f_args
Ellipsis, # f_arg_types
Ellipsis, # f_ret_types
)
del props
# python props, tricky since we don't know much about them.
for prop_id, attr in struct_info.get_py_properties():
dump_class[prop_id] = (
"prop_py", # basic_type
Ellipsis, # name
Ellipsis, # type
Ellipsis, # range
Ellipsis, # length
Ellipsis, # default
attr.__doc__, # descr
Ellipsis, # f_args
Ellipsis, # f_arg_types
Ellipsis, # f_ret_types
)
# kludge func -> props
funcs = [(func.identifier, func) for func in struct_info.functions]
for func_id, func in funcs:
func_ret_types = tuple([prop.type for prop in func.return_values])
func_args_ids = tuple([prop.identifier for prop in func.args])
func_args_type = tuple([prop.type for prop in func.args])
dump_class[func_id] = (
"func_rna", # basic_type
Ellipsis, # name
Ellipsis, # type
Ellipsis, # range
Ellipsis, # length
Ellipsis, # default
func.description, # descr
func_args_ids, # f_args
func_args_type, # f_arg_types
func_ret_types, # f_ret_types
)
del funcs
# kludge func -> props
funcs = struct_info.get_py_functions()
for func_id, attr in funcs:
# arg_str = inspect.formatargspec(*inspect.getargspec(py_func))
sig = inspect.signature(attr)
func_args_ids = [k for k, v in sig.parameters.items()]
dump_class[func_id] = (
"func_py", # basic_type
Ellipsis, # name
Ellipsis, # type
Ellipsis, # range
Ellipsis, # length
Ellipsis, # default
attr.__doc__, # descr
func_args_ids, # f_args
Ellipsis, # f_arg_types
Ellipsis, # f_ret_types
)
del funcs
import pprint
filename = api_dunp_fname()
filehandle = open(filename, 'w', encoding='utf-8')
tot = filehandle.write(pprint.pformat(dump, width=1))
filehandle.close()
print("%s, %d bytes written" % (filename, tot))
if rna_prop:
GetInfoOperatorRNA(rna_prop.bl_rna)
for rna_info in InfoOperatorRNA.global_lookup.values():
rna_info.build()
for rna_prop in rna_info.args:
rna_prop.build()
#for rna_info in InfoStructRNA.global_lookup.values():
# print(rna_info)
return InfoStructRNA.global_lookup, InfoFunctionRNA.global_lookup, InfoOperatorRNA.global_lookup, InfoPropertyRNA.global_lookup
if __name__ == "__main__":
import rna_info
struct = rna_info.BuildRNAInfo()[0]
data = []
for struct_id, v in sorted(struct.items()):
struct_id_str = v.identifier #~ "".join(sid for sid in struct_id if struct_id)
for base in v.get_bases():
struct_id_str = base.identifier + "|" + struct_id_str
props = [(prop.identifier, prop) for prop in v.properties]
for prop_id, prop in sorted(props):
# if prop.type == "boolean":
# continue
prop_type = prop.type
if prop.array_length > 0:
prop_type += "[%d]" % prop.array_length
