Python bpy 模块，ops() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用bpy.ops()。
def updater_run_success_popup_handler(scene):
global ran_update_sucess_popup
ran_update_sucess_popup = True
# in case of error importing updater
if updater.invalidupdater == True:
return
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_success_popup_handler)
except:
pass
atr = addon_updater_updated_successful.bl_idname.split(".")
getattr(getattr(bpy.ops, atr[0]),atr[1])('INVOKE_DEFAULT')
def post_update_callback():
# in case of error importing updater
if updater.invalidupdater == True:
return
# this is the same code as in conditional at the end of the register function
# ie if "auto_reload_post_update" == True,comment out this code
if updater.verbose: print("{} updater: Running post update callback".format(updater.addon))
#bpy.app.handlers.scene_update_post.append(updater_run_success_popup_handler)
atr = addon_updater_updated_successful.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
global ran_update_sucess_popup
ran_update_sucess_popup = True
return
# function for asynchronous background check,which *could* be called on register
def __repr__(self): # useful display,repr(op)
# import bpy
idname = self.idname()
as_string = op_as_string(idname)
# XXX You never quite know what you get from bpy.types,
# with operators... Operator and OperatorProperties
# are shadowing each other,and not in the same way for
# native ops and py ones! See T39158.
# op_class = getattr(bpy.types,idname)
op_class = op_get_rna(idname)
descr = op_class.bl_rna.description
# XXX,workaround for not registering
# every __doc__ to save time on load.
if not descr:
descr = op_class.__doc__
if not descr:
descr = ""
return "# %s\n%s" % (descr, as_string)
def post_update_callback():
# in case of error importing updater
if updater.invalidupdater == True:
return
# this is the same code as in conditional at the end of the register function
# ie if "auto_reload_post_update" == True,which *could* be called on register
def importMesh_PointSet(geom, ancestry, _):
# VRML not x3d
coord = geom.getChildBySpec('Coordinate') # works for x3d and vrml
if coord:
points = coord.getFieldAsArray('point', 3, ancestry)
else:
points = []
# vcolor = geom.getChildByName('color')
# blender dosnt have per vertex color
bpymesh = bpy.data.meshes.new("PointSet")
bpymesh.vertices.add(len(points))
bpymesh.vertices.foreach_set("co", [a for v in points for a in v])
# No need to validate
bpymesh.update()
return bpymesh
# -----------------------------------------------------------------------------------
# Primitives
# SA: they used to use bpy.ops for primitive creation. That was
# unbelievably slow on complex scenes. I rewrote to generate meshes
# by hand.
def get_ops():
allops = []
opsdir = dir(bpy.ops)
for opmodname in opsdir:
opmod = getattr(bpy.ops, opmodname)
opmoddir = dir(opmod)
for o in opmoddir:
name = opmodname + "." + o
clazz = getclazz(name)
if (clazz.__module__ != 'bpy.types'):
allops.append(name)
del opmoddir
# add own operator name too,since its not loaded yet when this is called
allops.append("text.edit_operator")
l = sorted(allops)
del allops
del opsdir
return [(y, y, "", x) for x, y in enumerate(l)]
def execute(self, context):
found = False
path, line, addon = getmodule(self.op)
if addon:
for t in bpy.data.texts:
if t.filepath == path:
ctx = context.copy()
ctx['edit_text'] = t
bpy.ops.text.jump(ctx, line=line)
found = True
break
if (found is False):
self.report({'INFO'},
"Opened file: " + path)
bpy.ops.text.open(filepath=path)
bpy.ops.text.jump(line=line)
return {'FINISHED'}
else:
self.report({'WARNING'},
"Found no source file for " + self.op)
return {'CANCELLED'}
def execute(self, context):
from os.path import basename, splitext
filepath = self.filepath
# change the menu title to the most recently chosen option
preset_class = getattr(bpy.types, self.menu_idname)
preset_class.bl_label = bpy.path.display_name(basename(filepath))
ext = splitext(filepath)[1].lower()
# execute the preset using script.python_file_run
if ext == ".py":
bpy.ops.script.python_file_run(filepath=filepath)
elif ext == ".xml":
import rna_xml
rna_xml.xml_file_run(context,
filepath,
preset_class.preset_xml_map)
else:
self.report({'ERROR'}, "unknown filetype: %r" % ext)
return {'CANCELLED'}
return {'FINISHED'}
def invoke(self, context, event):
wm = context.window_manager
data_path = self.data_path
prop_string = self.prop_string
# same as eval("bpy.ops." + data_path)
op_mod_str, ob_id_str = data_path.split(".", 1)
op = getattr(getattr(bpy.ops, op_mod_str), ob_id_str)
del op_mod_str, ob_id_str
try:
op_rna = op.get_rna()
except KeyError:
self.report({'ERROR'}, "Operator not found: bpy.ops.%s" % data_path)
return {'CANCELLED'}
def draw_cb(self, context):
layout = self.layout
pie = layout.menu_pie()
pie.operator_enum(data_path, prop_string)
wm.popup_menu_pie(draw_func=draw_cb, title=op_rna.bl_rna.name, event=event)
return {'FINISHED'}
def execute(self, context):
op_strings = []
tot = 0
for op_module_name in dir(bpy.ops):
op_module = getattr(bpy.ops, op_module_name)
for op_submodule_name in dir(op_module):
op = getattr(op_module, op_submodule_name)
text = repr(op)
if text.split("\n")[-1].startswith("bpy.ops."):
op_strings.append(text)
tot += 1
op_strings.append('')
textblock = bpy.data.texts.new("OperatorList.txt")
textblock.write('# %d Operators\n\n' % tot)
textblock.write('\n'.join(op_strings))
self.report({'INFO'}, "See OperatorList.txt textblock")
return {'FINISHED'}
# -----------------------------------------------------------------------------
# Add-on Operators
def execute(self, context):
import addon_utils
module_name = self.module
modules = addon_utils.modules(refresh=False)
mod = addon_utils.addons_fake_modules.get(module_name)
if mod is not None:
info = addon_utils.module_bl_info(mod)
info["show_expanded"] = True
bpy.context.user_preferences.active_section = 'ADDONS'
context.window_manager.addon_filter = 'All'
context.window_manager.addon_search = info["name"]
bpy.ops.screen.userpref_show('INVOKE_DEFAULT')
return {'FINISHED'}
# Note: shares some logic with WM_OT_addon_install
# but not enough to de-duplicate. Fixes here may apply to both.
def execute(self,context):
if updater.update_ready == True:
res = updater.run_update(force=False, callback=post_update_callback)
# should return 0,if not something happened
if updater.verbose:
if res==0: print("Updater returned successful")
else: print("Updater returned "+str(res)+",error occured")
elif updater.update_ready == None:
(update_ready, version, link) = updater.check_for_update(now=True)
# re-launch this dialog
atr = addon_updater_install_popup.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
#bpy.ops.retopoflow.updater_install_popup('INVOKE_DEFAULT')
else:
if updater.verbose:print("Doing nothing,not ready for update")
return {'FINISHED'}
# User preference check-now operator
def updater_run_install_popup_handler(scene):
global ran_autocheck_install_popup
ran_autocheck_install_popup = True
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_install_popup_handler)
except:
pass
if "ignore" in updater.json and updater.json["ignore"] == True:
return # don't do popup if ignore pressed
atr = addon_updater_install_popup.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
# passed into the updater,background thread updater
def execute(self,not ready for update")
return {'FINISHED'}
# User preference check-now operator
def updater_run_install_popup_handler(scene):
global ran_autocheck_install_popup
ran_autocheck_install_popup = True
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_install_popup_handler)
except:
pass
if "ignore" in updater.json and updater.json["ignore"] == True:
return # don't do popup if ignore pressed
atr = addon_updater_install_popup.bl_idname.split(".")
getattr(getattr(bpy.ops,background thread updater
def updater_run_success_popup_handler(scene):
global ran_update_sucess_popup
ran_update_sucess_popup = True
# in case of error importing updater
if updater.invalidupdater == True:
return
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_success_popup_handler)
except:
pass
atr = addon_updater_updated_successful.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
def post_update_callback():
# in case of error importing updater
if updater.invalidupdater == True:
return
# this is the same code as in conditional at the end of the register function
# ie if "auto_reload_post_update" == True,which *could* be called on register
def updater_run_success_popup_handler(scene):
global ran_update_sucess_popup
ran_update_sucess_popup = True
# in case of error importing updater
if updater.invalidupdater == True:
return
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_success_popup_handler)
except:
pass
atr = addon_updater_updated_successful.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
def post_update_callback():
# in case of error importing updater
if updater.invalidupdater == True:
return
# this is the same code as in conditional at the end of the register function
# ie if "auto_reload_post_update" == True,which *could* be called on register
def iter_exporters():
#categories = dir(bpy.ops)
categories = ["export_anim", "export_mesh", "export_scene"]
for category_name in categories:
op_category = getattr(bpy.ops, category_name)
for name in dir(op_category):
total_name = category_name + "." + name
if total_name == ExportSelected.bl_idname:
continue
if "export" in total_name:
op = getattr(op_category, name)
yield total_name, op
def execute(self, context):
with ToggleObjectMode(undo=None):
self.clear_world(context)
if self.format:
props = {}
for key in CurrentFormatProperties._keys():
props[key] = getattr(self.format_props, key)
props["filepath"] = self.filepath
op = get_op(self.format)
op(**props)
else:
bpy.ops.wm.save_as_mainfile(
filepath=self.filepath,
copy=True,
)
bpy.ops.ed.undo()
bpy.ops.ed.undo_push(message="Export Selected")
return {'FINISHED'}
def execute(self, context):
selected_rock = active()
try:
is_rock = selected_rock.get('ROCK_GENERATOR')
except KeyError:
self.report({'ERROR'}, "No active rock object!")
return {'CANCELLED'}
if not is_rock:
self.report({'ERROR'}, "No active rock object!")
return {'CANCELLED'}
for s in context.selected_objects:
s.select = False
selected_rock.select = True
bpy.ops.object.delete(use_global=False)
build_rock(context)
return {'FINISHED'}
def updater_run_success_popup_handler(scene):
global ran_update_sucess_popup
ran_update_sucess_popup = True
# in case of error importing updater
if updater.invalidupdater == True:
return
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_success_popup_handler)
except:
pass
atr = ARCHIPACK_OT_updater_updated_successful.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
def post_update_callback():
# in case of error importing updater
if updater.invalidupdater == True:
return
# this is the same code as in conditional at the end of the register function
# ie if "auto_reload_post_update" == True,comment out this code
if updater.verbose: print("{} updater: Running post update callback".format(updater.addon))
#bpy.app.handlers.scene_update_post.append(updater_run_success_popup_handler)
atr = ARCHIPACK_OT_updater_updated_successful.bl_idname.split(".")
getattr(getattr(bpy.ops,which *could* be called on register
def importMesh_PointSet(geom, [a for v in points for a in v])
# No need to validate
bpymesh.update()
return bpymesh
# -----------------------------------------------------------------------------------
# Primitives
# SA: they used to use bpy.ops for primitive creation. That was
# unbelievably slow on complex scenes. I rewrote to generate meshes
# by hand.
def get_obj_mesh_pair(obj, context):
log.debug('Transforming object into mesh: %s', obj.name)
mesh = obj.to_mesh(context.scene, apply_modifiers=True, settings='RENDER')
mesh.name = obj.name
mesh.transform(Matrix.Rotation(-math.pi / 2, 4, 'X') * obj.matrix_world)
bm = bmesh.new()
bm.from_mesh(mesh)
bmesh.ops.triangulate(bm, faces=bm.faces)
bm.to_mesh(mesh)
bm.free()
del bm
mesh.calc_normals()
mesh.calc_tessface()
return (obj, mesh)
def execute(self,not ready for update")
return {'FINISHED'}
# User preference check-now operator
def updater_run_install_popup_handler(scene):
global ran_autocheck_install_popup
ran_autocheck_install_popup = True
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_install_popup_handler)
except:
pass
if "ignore" in updater.json and updater.json["ignore"] == True:
return # don't do popup if ignore pressed
atr = addon_updater_install_popup.bl_idname.split(".")
getattr(getattr(bpy.ops,background thread updater
def updater_run_success_popup_handler(scene):
global ran_update_sucess_popup
ran_update_sucess_popup = True
# in case of error importing updater
if updater.invalidupdater == True:
return
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_success_popup_handler)
except:
pass
atr = addon_updater_updated_successful.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
def post_update_callback(res=None):
# in case of error importing updater
if updater.invalidupdater == True:
return
if res==None:
# this is the same code as in conditional at the end of the register function
# ie if "auto_reload_post_update" == True,comment out this code
if updater.verbose: print("{} updater: Running post update callback".format(updater.addon))
#bpy.app.handlers.scene_update_post.append(updater_run_success_popup_handler)
atr = addon_updater_updated_successful.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
global ran_update_sucess_popup
ran_update_sucess_popup = True
else:
# some kind of error occured and it was unable to install,
# offer manual download instead
atr = addon_updater_updated_successful.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT',error=res)
return
# function for asynchronous background check,which *could* be called on register
def execute(self, context):
activeObj = context.active_object
for SelectedObject in bpy.context.selected_objects :
bpy.context.scene.objects.active = SelectedObject
oldMode = SelectedObject.mode
bpy.ops.object.mode_set(mode='OBJECT')
for md in SelectedObject.modifiers :
# apply the modifier
try:
bpy.ops.object.modifier_apply(apply_as='DATA', modifier=md.name)
except:
pass
bpy.ops.object.mode_set(mode=oldMode)
bpy.context.scene.objects.active = activeObj
return {'FINISHED'}
def boolean_optimized(mode):
context = bpy.context
obj = context.active_object
object_prepare()
obj.select = False
obs = context.selected_objects
ob = obs[0]
if len(obs) != 1:
context.scene.objects.active = ob
bpy.ops.object.join()
context.scene.objects.active = obj
mesh_selection(obj, 'DESELECT')
mesh_selection(ob, 'SELECT')
modifier_boolean(obj, ob, mode)
obj.select = True
def union():
context = bpy.context
mode = 'UNION'
def separate():
ops = bpy.ops
ops_ob = ops.object
ops_ob.mode_set(mode="EDIT")
ops.mesh.separate(type="LOOSE")
ops_ob.mode_set(mode="OBJECT")
boolean_optimized(mode)
separate()
if len(context.selected_objects) != 1:
boolean_each(mode)
def boolean_optimized(mode):
context = bpy.context
obj = context.active_object
object_prepare()
obj.select = False
obs = context.selected_objects
ob = obs[0]
if len(obs) != 1:
context.scene.objects.active = ob
bpy.ops.object.join()
context.scene.objects.active = obj
mesh_selection(obj, mode)
obj.select = True
def updater_run_install_popup_handler(scene):
global ran_autocheck_install_popup
ran_autocheck_install_popup = True
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_install_popup_handler)
except:
pass
if "ignore" in updater.json and updater.json["ignore"] == True:
return # don't do popup if ignore pressed
atr = addon_updater_install_popup.bl_idname.split(".")
getattr(getattr(bpy.ops, atr[1])('INVOKE_DEFAULT')
# passed into the updater,background thread updater
def updater_run_success_popup_handler(scene):
global ran_update_sucess_popup
ran_update_sucess_popup = True
# in case of error importing updater
if updater.invalidupdater == True:
return
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_success_popup_handler)
except:
pass
atr = addon_updater_updated_successful.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
def post_update_callback():
# in case of error importing updater
if updater.invalidupdater == True:
return
# this is the same code as in conditional at the end of the register function
# ie if "auto_reload_post_update" == True,which *could* be called on register
def __init__(self):
bpy.ops.object.mode_set(mode='OBJECT')
object_ = bpy.context.active_object
self.node_name = object_.name
self.node_type = 'cgf'
if object_.type not in ('MESH', 'EMPTY'):
self.report(
{'ERROR'},
"Selected object is not a mesh! Please select a mesh object.")
return {'FINISHED'}
if object_.parent and object_.parent.type == 'ARMATURE':
if len(object_.data.vertices) <= 4:
self.node_type = 'chr'
self.node_name = object_.parent.name
else:
self.node_type = 'skin'
elif object_.animation_data:
self.node_type = 'cga'
def execute(self, context):
if bpy.context.selected_objects:
scene = bpy.context.scene
node_name = "{}.{}".format(self.node_name, self.node_type)
group = bpy.data.groups.get(node_name)
if group is None:
bpy.ops.group.create(name=node_name)
else:
for object in bpy.context.selected_objects:
if object.name not in group.objects:
group.objects.link(object)
message = "Adding Export Node"
else:
message = "No Objects Selected"
self.report({"INFO"}, message)
return {"FINISHED"}
def execute(self, context):
old_cursor = context.scene.cursor_location.copy()
for obj in context.selected_objects:
ctx = utils.override(obj, active=True, selected=True)
bpy.ops.object.origin_set(
ctx, type="ORIGIN_GEOMETRY", center="BOUNDS")
bpy.ops.view3d.snap_cursor_to_selected(ctx)
x, z = bpy.context.scene.cursor_location
z = obj.location.z - obj.dimensions.z / 2 - self.z_offset
bpy.context.scene.cursor_location = Vector((x, z))
bpy.ops.object.origin_set(ctx, type="ORIGIN_CURSOR")
bpy.context.scene.cursor_location = Vector((0, 0, 0))
bpy.ops.view3d.snap_selected_to_cursor(ctx)
bpy.context.scene.cursor_location = old_cursor
return {'FINISHED'}
def execute(self, context):
active_object = bpy.context.active_object
bpy.ops.object.mode_set(mode='OBJECT')
selected_vert_coordinates = get_vertex_data()
if (selected_vert_coordinates):
selected_vert = selected_vert_coordinates[0]
bpy.ops.object.add(
type='EMPTY',
view_align=False,
enter_editmode=False,
location=(
selected_vert[0],
selected_vert[1],
selected_vert[2]))
empty_object = bpy.context.active_object
empty_object.name = name_branch(True)
utils.set_active(active_object)
bpy.ops.object.mode_set(mode='EDIT')
message = "Adding Branch"
self.report({'INFO'}, message)
bcPrint(message)
return {'FINISHED'}
def execute(self, context):
mesh = bpy.context.active_object.data
vert_list = [vert for vert in mesh.vertices]
context.tool_settings.mesh_select_mode = (True, False, False)
bpy.ops.object.mode_set(mode='OBJECT')
bcPrint("Locating degenerate faces.")
for i in mesh.edges:
counter = 0
for polygon in mesh.polygons:
if (i.vertices[0] in polygon.vertices
and i.vertices[1] in polygon.vertices):
counter += 1
if counter > 2:
bcPrint('Found a multi-face line')
for v in i.vertices:
bcPrint('Selecting line vertices.')
vert_list[v].select = True
bpy.ops.object.mode_set(mode='EDIT')
return {'FINISHED'}
def __init__(self):
armature = bpy.context.active_object
if not armature or armature.type != 'ARMATURE':
self.report({'ERROR'}, "Please select a armature object!")
return {'FINISHED'}
elif armature.pose.bones.find('Root') != -1:
message = "{} armature already has a Root bone!".format(
armature.name)
self.report({'INFO'}, message)
return {'FINISHED'}
bpy.ops.object.mode_set(mode='EDIT')
root_bone = utils.get_root_bone(armature)
loc = root_bone.head
if loc.x == 0 and loc.y == 0 and loc.z == 0:
message = "Armature already has a root/center bone!"
self.report({'INFO'}, message)
return {'FINISHED'}
else:
self.hips_bone = root_bone.name
def __set_primitive_mesh_material(self, armature, materials):
object_ = utils.get_chr_object_from_skeleton(armature)
object_.select = True
bpy.context.scene.objects.active = object_
mat = None
if self.use_single_material:
mat = materials['single']
else:
mat = materials['primitive']
if object_.material_slots:
object_.material_slots[0].material = mat
else:
bpy.ops.object.material_slot_add()
if object_.material_slots:
object_.material_slots[0].material = mat
object_.select = False
def execute(self, context):
bcPrint(Configuration.rc_path, 'debug', True)
try:
config = Export.Config(config=self)
if self.run_in_profiler:
import cProfile
cProfile.runctx('export.save(config)', {},
{'export': export, 'config': config})
else:
export.save(config)
self.filepath = '//'
except exceptions.BCryException as exception:
bcPrint(exception.what(), 'error')
bpy.ops.screen.display_error(
'INVOKE_DEFAULT', message=exception.what())
return {'FINISHED'}
def execute(self, 'debug')
try:
config = ExportAnimations.Config(config=self)
if self.run_in_profiler:
import cProfile
cProfile.runctx(
'export_animations.save(config)', {
'export_animations': export_animations, 'config': config})
else:
export_animations.save(config)
self.filepath = '//'
except exceptions.BCryException as exception:
bcPrint(exception.what(), message=exception.what())
return {'FINISHED'}
def execute(self,context):
# in case of error importing updater
if updater.invalidupdater == True:
return {'CANCELLED'}
if updater.manual_only==True:
row.operator("wm.url_open",text="Open website").url=\
updater.website
elif updater.update_ready == True:
res = updater.run_update(force=False,error occurred")
elif updater.update_ready is None:
(update_ready,atr[1])('INVOKE_DEFAULT')
else:
if updater.verbose:print("Doing nothing,not ready for update")
return {'FINISHED'}
# User preference check-now operator
def execute(self,context):
# in case of error importing updater
if updater.invalidupdater == True:
return {'CANCELLED'}
if updater.manual_only == True:
row.operator("wm.url_open",text="Open website").url=\
updater.website
if updater.update_ready == True:
# if it fails,offer to open the website instead
try:
res = updater.run_update(
force=False,
callback=post_update_callback)
# should return 0,if not something happened
if updater.verbose:
if res==0: print("Updater returned successful")
else: print("Updater returned "+str(res)+",error occurred")
except:
atr = addon_updater_install_manually.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
elif updater.update_ready is None:
(update_ready, link) = updater.check_for_update(now=True)
# re-launch this dialog
atr = addon_updater_install_popup.bl_idname.split(".")
getattr(getattr(bpy.ops,atr[1])('INVOKE_DEFAULT')
elif updater.update_ready == False:
self.report({'INFO'}, "Nothing to update")
else:
self.report({'ERROR'}, "Encountered problem while trying to update")
return {'FINISHED'}
def updater_run_install_popup_handler(scene):
global ran_autocheck_install_popup
ran_autocheck_install_popup = True
# in case of error importing updater
if updater.invalidupdater == True:
return
try:
bpy.app.handlers.scene_update_post.remove(
updater_run_install_popup_handler)
except:
pass
if "ignore" in updater.json and updater.json["ignore"] == True:
return # don't do popup if ignore pressed
elif type(updater.update_version) != type((0,0,0)):
# likely was from master or another branch,shouldn't trigger popup
updater.json_reset_restore()
return
elif "version_text" in updater.json and "version" in updater.json["version_text"]:
version = updater.json["version_text"]["version"]
ver_tuple = updater.version_tuple_from_text(version)
if ver_tuple < updater.current_version:
# user probably manually installed to get the up to date addon
# in here. Clear out the update flag using this function
if updater.verbose:
print("{} updater: appears user updated,clearing flag".format(\
updater.addon))
updater.json_reset_restore()
return
atr = addon_updater_install_popup.bl_idname.split(".")
getattr(getattr(bpy.ops,background thread updater
def add_scrollback(text, text_type):
for l in text.split("\n"):
bpy.ops.console.scrollback_append(text=l.replace("\t", " "),
type=text_type)
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 [email protected] 举报，一经查实，本站将立刻删除。