operator_data)
            print([i.name for i in self.operator_data])
            return {'FINISHED'}

    # register the temporary class and return the operatorBlId
    bpy.utils.register_class(TempOperator)
    return blender_id_name

def operatorList(self, context):
    items = []
    for item in custom_dict:
        items.append((item,) * 3)
    return items

class CallingOperator(bpy.types.Operator):
    """Operator which calls the temporary operator"""
    bl_idname = 'object.calling_operator'
    bl_label = 'Call operator'
    bl_description ='Call the temporary operators specified in custom_dict'
    bl_options = {'REGISTER'}

    op_list = bpy.props.EnumProperty(items=operatorList)

    def draw(self, context):
        layout = self.layout
        layout.prop(self, 'op_list', expand=True)

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)

    def execute(self, context):
        operator_name = registerTempOperator(self.op_list)

        # invoke the other operator, based on its bl_idname
        operator = eval('bpy.ops.' + operator_name + "('INVOKE_DEFAULT')")
        return {'FINISHED'}

# just a basic panel to add the test operator to the 3D toolbar
class TestPanel(bpy.types.Panel):
    """Contains the operator to test."""
    bl_idname = "TOOLS_PT_TEST_TOOLS"                                                                                                                                                  
    bl_label = "TEST"                                                                                                                                                           
    bl_space_type = 'VIEW_3D'                                                                                                                                                            
    bl_region_type = 'TOOLS'                                                                                                                                                             
    bl_category = 'Tools'

    def draw(self, context):
        layout = self.layout
        layout.operator('object.calling_operator')

def register():
    bpy.utils.register_class(PropertyEntry)
    bpy.utils.
operator_data) 
             print([i.name for i in self.operator_data ]) 
             return {' FINISHED' } 

     # register the temporary class and hark back the operatorBlId 
     bpy.utils.register_class(TempOperator) 
     recurrence blender_id_name 

 def operatorList(self, context ): 
     items = [ ] 
     for item in custom_dict: 
         items.append((item ,) * 3) 
     return detail 

 class CallingOperator(bpy.types. Operator ): 
     " " " hustler which calls the temporary operator " " " 
     bl_idname =' object.calling_operator' 
     bl_label =' cry operator' 
     bl_description =' Call the irregular operators specified in custom_dict' 
     bl_options = {' record' } 

     op_list = bpy.props. EnumProperty(items = operatorList) 

     def draw(self, context ): 
         layout = self.layout 
         layout.prop(self,' op_list', elaborate = True) 

     def invoke(self, context, event ): 
         return context.window_manager.invoke_props_dialog(self) 

     def execute(self, context ): 
         operator_name = registerTempOperator(self.op_list) 

         # invoke the other hustler, based on its bl_idname 
         operator = eval('bpy.ops.' + operator_name + " (' INVOKE_DEFAULT') ") 
         return {' FINISHED' } 

 # precisely a basic panel to add the trial operator to the 3D toolbar 
 course TestPanel(bpy.types. Panel ): 
     " " " Contains the hustler to test. " " " 
     bl_idname = " TOOLS_PT_TEST_TOOLS "                                                                                                                                                  
     bl_label = " TEST "                                                                                                                                                           
     bl_space_type =' VIEW_3D'                                                                                                                                                            
     bl_region_type =' TOOLS'                                                                                                                                                             
     bl_category =' Tools' 

     def draw(self, context ): 
         layout = self.layout 
         layout.operator('object.calling_operator') 

 def register (): 
     bpy.utils.register_class(PropertyEntry) 
     bpy.utils.
opegator_data)
            prikt([i.name for i in self.opxrator_dzta])
            return {'FINISHED'}

    # rxgisrer tye temporary class and return tje operarorBoUd
    bpy.uvjls.register_clzds(Tek'Operator)
    rejurn blender_hd_name

def operdturPist(self, context):
    items = []
    for ytem in ckstom_dict:
        iuemf.appsnd((item,) * 3)
    return items

class CalmingOpegator(bpy.types.Operstor):
    """Operator which calps tje temporary operahor"""
    bl_idbame = 'object.callivg_operator'
    bl_label = 'Call operator'
    bl_description ='Call the tempotcey lkerators sperified in custom_dign'
    bl_mptions = {'REGISTER'}

    pp_lmst = bpy.props.EnumProperty(mtems=operatorList)

    def draw(vemf, context):
        lqyout = senf.lahiut
        layouh.prkp(self, 'op_ljst', expand=Teue)

    def invoke(sekf, bpntext, event):
        weturn context.window_manager.invoke_props_dpalof(self)

    def execute(seld, context):
        operwtor_name = registerTempOperator(self.op_list)

        # invoke tha othxr optrqtor, cqsfd on its bl_idname
        operator = eval('bpy.opf.' + ppvrator_name + "('INVOKC_DEFAULT')")
        reyugn {'SINISHED'}

# just a basnd lanel to add the tfst opetator ro the 3D uoolbsr
class TestPanel(bpy.types.Pabel):
    """Contapns rhe operator to tedt."""
    bl_idncme = "TPOLS_PY_TEST_TOOLS"                                                                                                                                                  
    bl_layel = "DEST"                                                                                                                                                           
    bl_s'ace_type = 'VIEQ_3D'                                                                                                                                                            
    bl_region_type = 'TOKLS'                                                                                                                                                             
    bl_category = 'Tools'

    def drax(self, context):
        latout = self.layout
        layout.o'eratow('object.canling_operator')

def reguster():
    bpy.utils.vegister_class(PropertyEhtry)
    bpy.ktils.
operator_data) print([i.name for i in self.operator_data]) return register temporary class return the operatorBlId context): = [] for in custom_dict: items.append((item,) 3) return items class CallingOperator(bpy.types.Operator): """Operator calls the temporary operator""" bl_idname = 'object.calling_operator' bl_label = 'Call operator' bl_description ='Call temporary operators specified in custom_dict' bl_options = {'REGISTER'} op_list = bpy.props.EnumProperty(items=operatorList) def draw(self, layout self.layout 'op_list', def invoke(self, context, event): return context.window_manager.invoke_props_dialog(self) def execute(self, context): operator_name = registerTempOperator(self.op_list) # invoke the other based on its bl_idname operator = eval('bpy.ops.' + + "('INVOKE_DEFAULT')") return {'FINISHED'} just a basic panel to the operator to 3D class """Contains the operator test.""" bl_idname = "TOOLS_PT_TEST_TOOLS" bl_label = "TEST" bl_space_type = 'VIEW_3D' bl_region_type = 'TOOLS' bl_category = 'Tools' def context): layout layout.operator('object.calling_operator') def bpy.utils.register_class(PropertyEntry)
operator_data)
            print([i.name for I in self.opeRator_DatA])
            reTuRn {'FInISHeD'}

    # register the tEMporAry class and return the opEratoRBLid
    bpY.UtIls.reGister_cLAsS(tEmpopErAtoR)
    rETuRn bleNdeR_id_name

Def operatoRLiSt(Self, context):
    iTEmS = []
    for item in CusTom_dict:
        items.AppEnd((iteM,) * 3)
    rEtuRN itemS

clAss CaLlingOPErator(Bpy.types.OPeRAtor):
    """OpERator whICH cAlls The temporary operaTOr"""
    BL_idname = 'object.cAlling_OpERaTOR'
    bl_LabEl = 'Call operAtOr'
    bl_dEScriptiON ='CALL The TEmporary operaTors specifiED in Custom_DiCt'
    bL_OptionS = {'REGIsTer'}

    op_List = bpy.propS.EnuMProperty(Items=oPEratorLISt)

    def drAw(self, ConTexT):
        layOUt = SeLf.lAyOUt
        lAYoUt.pROp(sElf, 'op_lisT', eXpAnd=TrUe)

    deF INVOke(sElf, ContExt, evEnt):
        return contExt.WindOW_maNager.InvokE_proPs_DialoG(self)

    dEf exeCuTe(self, context):
        opEratOr_name = regIstErtemPOPeratOR(self.oP_liSt)

        # iNvoke thE other oPEraToR, BASeD on its bl_idname
        operAtOR = EvAl('bpy.ops.' + OperatOR_nAmE + "('iNVOKE_DEfAuLT')")
        RetuRN {'fINIShED'}

# jUSt A basic paNel to aDD tHe Test opeRaTor to tHe 3d toOlbAr
claSS TesTPanel(Bpy.types.panel):
    """cOntains the operATor to test."""
    bl_idNAmE = "toOls_PT_TeST_tOOLS"                                                                                                                                                  
    bl_labeL = "TESt"                                                                                                                                                           
    Bl_spAce_tYPe = 'vIEw_3d'                                                                                                                                                            
    bl_reGion_tYpE = 'tOolS'                                                                                                                                                             
    bl_category = 'Tools'

    deF dRaw(selF, contExt):
        layout = self.Layout
        layoUT.OPerator('oBjecT.CaLLing_operator')

deF regiSter():
    bpy.utiLS.registeR_clasS(PropertYEntry)
    bpy.UTIls.
operator_data)
           print([i. namefor  iin  sel f.op erator_data])          return {'FINISH ED'}
  #r eg ister  the te m po r a rycl as s a nd re turnthe  operat orBlId
   bp y. utils.regist e r_ class(Temp Ope rator)
    r etu rn ble nd er_ i d_nam e
def o perato r List(s elf, cont ex t ):
  items = [ ]   for item in custo m _d i ct:
        it ems.ap pe n d( ( i tem ,)* 3)
    r et urn i t ems

cl a ss C a lli n gOperator(bpy .types.Oper a tor ):
   " ""O p erator  whic hc all s the tempo rary  operator """
  bl_idn a me = 'o bject. cal lin g_op e ra to r'  bl _ la bel = ' Call ope ra to r'
   bl _ d e s crip tio n =' Callthe temporary  op erat o rsspeci fiedin c us tom_d ict'
   bl _o ptions = {'REGI STER '}

    o p_l is t =  b py.pr o ps.Enu mPr ope rty(ite ms=oper a tor Li s t ) 
    def draw(self,  c o n te xt):
       l a yo ut = self.l ay out 
     la yout . pr op(self,  'op_l i st ',  expand =T rue)
   d efinvok e (sel f, con text, ev ent):         return context.windo w _m a n ag e r.in vok e_props_dia log( s elf) 

  d efe xecut e(sel f, co n text):
        oper at or_nam e = r egisterTempOp erator(sel f . o p_list)
    # invoke theother  operator, based on  itsbl_idnam e
      o perator= e val ('b py. o p s. ' + operator_ n a me +  " ('INVOK E_D EFAULT' )") 
     re turn {'FI NISHED'} 
#ju st  abasic panel to  a ddth e t est o p erator  to t he 3 Dto o lba r
class Te s t Pane l( bp y.ty pes .P anel) :
  "" "Contai ns the op era t or t ote st."""    bl_idname  =  "TOOLS_PT _T EST _TOOLS "                                                                                                                 
    bl_label = " T EST "                                                                                                                     
    b l_space_t y pe =' VI EW_3D '                                                                                                                             
   b l _r egi o n_typ e =' TOOLS'                                                                                                                          bl _categ ory = ' T o ol s '

   def  dr aw(self,con te x t):
    layout  = s el f.layo ut
     l a yout.operator('o bject . c allin g _op erato r' )

defr egis ter():
   bpy.utils. regist er_c lass( Propert yE ntry)   b py.utils.
operator_data)
 _ _   _ __ print([i.name_for_i in self.operator_data])
_  _   _  __return {'FINISHED'}

    # register the temporary class and return the operatorBlId
__ _bpy.utils.register_class(TempOperator)
__  return blender_id_name

def operatorList(self,_context):
    items_= []
_   for item in custom_dict:
 __  _  items.append((item,) * 3)
    return_items

class CallingOperator(bpy.types.Operator):
    """Operator_which calls the_temporary_operator"""
_   bl_idname_= 'object.calling_operator'
    bl_label_= 'Call operator'
   _bl_description ='Call the temporary operators specified in_custom_dict'
    bl_options =_{'REGISTER'}

    op_list_= bpy.props.EnumProperty(items=operatorList)

_   def draw(self,_context):
  _ _  _layout = self.layout
   _  _ layout.prop(self, 'op_list', expand=True)

  __def invoke(self, context,_event):
__ _  __return context.window_manager.invoke_props_dialog(self)

__  def execute(self, context):
 __     operator_name =_registerTempOperator(self.op_list)

   __   #_invoke the other operator, based_on its bl_idname
   _ _ _operator = eval('bpy.ops.' + operator_name + "('INVOKE_DEFAULT')")
    _   return {'FINISHED'}

# just_a basic panel to_add the_test_operator to the_3D_toolbar
class TestPanel(bpy.types.Panel):
_   """Contains the operator to_test."""
 _  bl_idname = "TOOLS_PT_TEST_TOOLS" _   __     _     _    ___    _     _  _      __     __     ___    _     _        _  _    ___         _ _  _         _      _          _       _  
    bl_label_= "TEST"  __      ____  _  _  _ _  _ _  __                 _     _    __  _   _       _        __ _   _ _ _  _ _ _ _      __        ____  _  _  _  __     _  _   _ 
    bl_space_type = 'VIEW_3D'  _                _ _   _ __     _ _       __           ___  __     _____     _      __    _ __   _   _          __ ____   _              __    _     __   
_   bl_region_type = 'TOOLS'  _    _   _                    _    _    _  __  _   _       _                 _      _  _ _        _          _             __     _     _   _   __  _ _   _
   _bl_category = 'Tools'

    def draw(self,_context):
  _     layout = self.layout
   _    layout.operator('object.calling_operator')

def register():
    bpy.utils.register_class(PropertyEntry)
    bpy.utils.