def do_append(self): """ """ #debug ''' self.debug('self.AppendingCollectionVariable is '+str(self.AppendingCollectionVariable)) ''' #TuplesList Case if SYS.getIsTuplesListBool(self.AppendingCollectionVariable): #debug ''' self.debug('This is a tuples list') ''' #Definition the KeyStrsList AppendedKeyStrsList=SYS.unzip(self.AppendingCollectionVariable,[0]) #Look for an AppendingNodeCollectionStr try: NodeCollectionStrIndexInt=AppendedKeyStrsList.index( "NodeCollectionStr" ) self.AppendedNodeCollectionStr=self.AppendingCollectionVariable[ NodeCollectionStrIndexInt ][1] ''' #self.AppendedKeyStrKeyStr='Noded'+self.AppendedNodeCollectionStr+'KeyStr' try: AppendedKeyStrIndexInt=AppendedKeyStrsList.index( self.AppendedKeyStrKeyStr ) self.AppendedKeyStr=self.AppendingCollectionVariable[KeyStrIndexInt][1] except: pass ''' NodeKeyStrIndexInt=AppendedKeyStrsList.index( "NodeKeyStr" ) self.AppendedNodeKeyStr=self.AppendingCollectionVariable[ NodeKeyStrIndexInt ][1] except: pass else: #Objects Case if "AppenderClass" in map( lambda __Class: __Class.__name__, type(self.AppendingCollectionVariable).__mro__ ): #debug ''' self.debug('This is a derived object from an Appender') ''' #set AppendedDict=self.AppendingCollectionVariable.__dict__ #dict Case elif type(self.AppendingCollectionVariable) in [dict,collections.OrderedDict]: AppendedDict=self.AppendingCollectionVariable try: #set self.AppendedNodeCollectionStr=AppendedDict["NodeCollectionStr"] self.AppendedNodeKeyStr=AppendedDict[ 'NodeKeyStr' ] except: pass #Init the SettingVariable and Add the NodifyingStr AppendedSettingKeyVariable=Noder.NodingPrefixGetStr+self.AppendedNodeCollectionStr+Noder.NodingSuffixGetStr+self.AppendedNodeKeyStr #debug self.debug([ ('self.',self,[ 'AppendedNodeCollectionStr', 'AppendedNodeKeyStr' ]) ] ) #Then set if AppendedSettingKeyVariable!=Noder.NodingPrefixGetStr+Noder.NodingSuffixGetStr: self.__setitem__( AppendedSettingKeyVariable, self.AppendingCollectionVariable )
def do_team(self): #debug ''' self.debug( ('self.',self,[ 'TeamingKeyStr', 'TeamingValueVariable' ]) ) ''' #Check if self.TeamingValueVariable==None: #try to get try: #get self.TeamedValueVariable=self.TeamDict[ self.TeamingKeyStr ] #set self.TeamedIsBool=True except KeyError: #init self.TeamedValueVariable=self.TeamingValueClass() #set self.TeamedIsBool=False else: #init self.TeamedIsBool=False #alias self.TeamedValueVariable=self.TeamingValueVariable #Check if self.TeamedIsBool==False: #/####################/# # Case where it is a dict or tuples list like # we wrap then in a manager new object #Check if hasattr( self.TeamedValueVariable, 'items' ) or SYS.getIsTuplesListBool(self.TeamedValueVariable): #init self.TeamedValueVariable=Manager.ManagerClass( )['#map@set']( self.TeamedValueVariable ) #set in the __dict__ self.__setattr__( self.TeamingKeyStr+type( self.TeamedValueVariable ).NameStr, self.TeamedValueVariable ) #put in the dict self.TeamDict[ self.TeamingKeyStr ]=self.TeamedValueVariable ########################## #give some team attributes # #debug ''' self.debug( 'We make point the teamed instance to self' ) ''' #set ''' self.TeamedValueVariable.point( self, 'TeamPointDeriveTeamer' ) ''' self.TeamedValueVariable.TeamPointDeriveTeamer=self #debug ''' self.debug( 'Ok it is pointed' ) ''' #set self.TeamedValueVariable.__setattr__( 'TeamTagStr', self.TeamingKeyStr )
def mimic_set(self): #Check if type(self.SettingKeyVariable)==str: #Check if self.SettingKeyVariable.startswith(ConnectGetSetPrefixStr): if type( self.SettingValueVariable )==list and SYS.getIsTuplesListBool(self.SettingValueVariable )==False and len(self.SettingValueVariable)==2: #debug ''' self.debug( [ 'We set connect here', ('self.',self,['SettingKeyVariable']) ] ) ''' #connect self.connect( SYS.deprefix( self.SettingKeyVariable, ConnectGetSetPrefixStr ), self.SettingValueVariable[0], self.SettingValueVariable[1] ) #return return {'HookingIsBool':False} else: #debug ''' self.debug( [ 'We set connect back here', ('self.',self,['SettingKeyVariable']) ] ) ''' #connect self.connect( SYS.deprefix( self.SettingKeyVariable, ConnectGetSetPrefixStr ), self.SettingValueVariable ) #return return {'HookingIsBool':False} #set BaseClass.set(self)
def do_array(self): #debug ''' self.debug( [ 'we array here', ('self.',self,['ArrayingKeyVariablesList']) ] ) ''' #Check if len(self.ArrayingKeyVariablesList)>0: #/####################/# # Is it going to be a set with several layers # #debug ''' self.debug( [ 'Is it going to be a set with several layers ?', ('self.',self,[ 'ArrayingKeyVariablesList', 'ArrayingValueVariable' ]) ] ) ''' #Check if SYS.getIsListsListBool(self.ArrayingKeyVariablesList): #debug ''' self.debug( [ 'set with several layers', ('self.',self,['ArrayingValueVariable']) ] ) ''' #/####################/# # Adapt the shape of the ValueVariable # #list default ArrayedLocalValueVariablesList=[] ArrayedDeepValueVariable=[] #Check if self.ArrayingValueVariable!=None: #Check if len( self.ArrayingValueVariable )==1 and len(self.ArrayingKeyVariablesList[0])>1: #listify self.ArrayingValueVariable=[self.ArrayingValueVariable] #Check if type(self.ArrayingValueVariable)!=list: #debug ''' self.debug( [ 'This is a total same setting', ('self.',self,[ 'ArrayingKeyVariablesList', 'ArrayingValueVariable' ]) ] ) ''' #list ArrayedLocalValueVariablesList=[self.ArrayingValueVariable]*len( self.ArrayingKeyVariablesList[0] ) ArrayedDeepValueVariable=self.ArrayingValueVariable elif len(self.ArrayingValueVariable)>0: #Check if SYS.getIsTuplesListBool(self.ArrayingValueVariable[0]) or hasattr( self.ArrayingValueVariable[0],'items' ): #debug ''' self.debug('This is an identical layered array setting') ''' #list ArrayedLocalValueVariablesList=[self.ArrayingValueVariable[0]]*len( self.ArrayingKeyVariablesList ) ArrayedDeepValueVariable=self.ArrayingValueVariable[1:] else: #debug ''' self.debug('This is an original layered setting') ''' #split ArrayedLocalValueVariablesList=self.ArrayingValueVariable[0] ArrayedDeepValueVariable=self.ArrayingValueVariable[1:] #debug ''' self.debug( [ 'ArrayedLocalValueVariablesList is '+str( ArrayedLocalValueVariablesList), 'ArrayedDeepValueVariable is '+str( ArrayedDeepValueVariable) ] ) ''' #/####################/# # Case where we have to set and then array deeper # #Check if len(self.ArrayingKeyVariablesList)>1: #debug ''' self.debug( [ 'self.ArrayingKeyVariablesList[0] is '+str(self.ArrayingKeyVariablesList[0]), 'ArrayedLocalValueVariablesList is '+str(ArrayedLocalValueVariablesList), 'first we set this layer' ] ) ''' #map ArrayedGetValueVariablesList=map( lambda __ArrayingKeyVariable,__ArrayingLocalValueVariable: self.set( __ArrayingKeyVariable, __ArrayingLocalValueVariable if __ArrayingLocalValueVariable!=None else {} )[__ArrayingKeyVariable], self.ArrayingKeyVariablesList[0], ArrayedLocalValueVariablesList ) #debug ''' self.debug( [ 'Now we array further', 'ArrayedDeepValueVariable'+str(ArrayedDeepValueVariable) ] ) ''' #map the next array map( lambda __ArrayedGetValueVariable: __ArrayedGetValueVariable.array( self.ArrayingKeyVariablesList[1:], ArrayedDeepValueVariable if type(ArrayedDeepValueVariable)!=list or len(ArrayedDeepValueVariable)>0 else None, False ), ArrayedGetValueVariablesList ) #/####################/# # Case where we have just to set # else: #debug ''' self.debug( [ 'ArrayedLocalValueVariablesList is', str(ArrayedLocalValueVariablesList), ('self.',self,['ArrayingKeyVariablesList']) ] ) ''' #map map( lambda __ArrayingKeyVariable,__ArrayingLocalValueVariable: self.set( __ArrayingKeyVariable, __ArrayingLocalValueVariable if __ArrayingLocalValueVariable!=None else {} ), self.ArrayingKeyVariablesList[0], ArrayedLocalValueVariablesList ) #/####################/# # It is just one layer # else: #/####################/# # Adapt the shape of the ValueVariable # #list default ArrayedLocalValueVariablesList=[] #Check if self.ArrayingValueVariable==None: #just a map get self['#map@get'](*self.ArrayingKeyVariablesList) #Check elif type(self.ArrayingValueVariable)==list: #debug self.debug('This is an identical non layered setting') #map set self['#map@set']( zip( self.ArrayingKeyVariablesList, self.ArrayingValueVariable ) ) else: #map set self['#map@set']( zip( self.ArrayingKeyVariablesList, [self.ArrayingValueVariable]*len(self.ArrayingKeyVariablesList) ) ) #debug '''
def do_manage(self): #debug ''' self.debug( ('self.',self,[ 'ManagingKeyStr', 'ManagingValueRigidVariable', 'ManagingWrapBool' ]) ) ''' #/###################/# # Force the repr with the ManagementDict # #Check if self.ManagedOnceBool==False: #extend self.PrintingInstanceForceKeyStrsList.extend( [ 'ManagementDict', #'TeamTagStr' ] ) #set self.ManagedOnceBool=True #reset self.TeamingValueClass=self.__class__.TeamingValueClass #/###################/# # Is it a new managed value # #in self.ManagedInBool=self.ManagingKeyStr in self.ManagementDict #debug ''' self.debug( [ 'Is it a new managed value ?', ('self.',self,[ 'ManagingKeyStr', 'ManagedInBool' ]) ] ) ''' #Check if self.ManagedInBool==False: #debug ''' self.debug( [ 'This is a new managed value', ('self.',self,['ManagingKeyStr']) ] ) ''' #/####################/# # Check if there is a special type for this # #debug ''' self.debug( [ 'Is there a special type for this', ('self.',self,['ManagingClassesDict','ManagingKeyStr']) ] ) ''' #Check if self.ManagingKeyStr in self.ManagingClassesDict: #get self.ManagingValueClass=self.ManagingClassesDict[ self.ManagingKeyStr ] #debug ''' self.debug( [ 'There is a special type for this', ('self.',self,['ManagingValueClass']) ] ) ''' #/####################/# # do we have to init # #debug ''' self.debug( [ 'This is a new managed value', ('self.',self,[ 'ManagingKeyStr', 'ManagingValueRigidVariable' ] ), 'Check first if this managingkey str is known' ] ) ''' #Check if self.ManagingValueRigidVariable==None: #init self.ManagedValueVariable=self.ManagingValueClass() else: #alias self.ManagedValueVariable=self.ManagingValueRigidVariable #/####################/# # Case where it is a dict or tuples list like # we wrap then in a teamer new object and ManagingWrapBool #temp ManagedTempValueVariable=None #Check if self.ManagingWrapBool and ( hasattr( self.ManagedValueVariable, 'items' ) or SYS.getIsTuplesListBool(self.ManagedValueVariable) ): #debug ''' self.debug( [ 'This is a manage with a value dict', 'We wrap into an instance', ('self.',self,[ 'ManagingKeyStr', 'ManagingValueClass', 'ManagingClassesDict' ]) ] ) ''' #Check if self.ManagingKeyStr in self.ManagingClassesDict: #get self.ManagingValueClass=self.ManagingClassesDict[ self.ManagingKeyStr ] #debug ''' self.debug( [ 'There is a special type for this', ('self.',self,['ManagingValueClass']) ] ) ''' #temp and init ManagedTempValueVariable=self.ManagedValueVariable self.ManagedValueVariable=self.ManagingValueClass() #debug ''' self.debug( [ 'Ok the wrapped dict has been setted', ('self.',self,['ManagedValueVariable']), 'ManagedTempValueVariable is ', SYS._str(ManagedTempValueVariable) ] ) ''' #/####################/# # Set different way to access it in the object # #Check if self.ManagingIndexInt>-1: #debug ''' self.debug( [ 'We manage by inserting', ('self.',self,[ 'ManagingIndexInt' ]) ] ) ''' #insert self.ManagementDict.insert( self.ManagingIndexInt, self.ManagedValueVariable, self.ManagingKeyStr, "Management" ) else: #debug ''' self.debug( [ 'We manage by just setting' ] ) ''' #put in the dict self.ManagementDict[ self.ManagingKeyStr ]=self.ManagedValueVariable #put in the dict self.ManagementDict[ self.ManagingKeyStr ]=self.ManagedValueVariable #Check if self.ManagingWrapBool: #debug ''' self.debug( [ 'We set also in the __dict__...' ] ) ''' #define the keystr to define in the dict ManagedKeyStr=self.ManagingKeyStr+type( self.ManagedValueVariable ).NameStr #set in the __dict__ self.__setattr__( ManagedKeyStr, self.ManagedValueVariable ) #add in the RepresentingSkipKeyStrsList to not be seen in the repr self.PrintingInstanceSkipKeyStrsList.append(ManagedKeyStr) #/########################/# # give some manage attributes # #set self.ManagedValueVariable.ManagementTagStr=self.ManagingKeyStr #index if self.ManagingIndexInt>-1: self.ManagedValueVariable.ManagementIndexInt=self.ManagingIndexInt else: self.ManagedValueVariable.ManagementIndexInt=len(self.ManagementDict)-1 #/##########################/ # If there are shared before set values # #debug ''' self.debug( [ 'The Manager has something before for the managed value ?', ('self.',self,['ManagingBeforeSetVariable']) ] ) ''' #Check if self.ManagingBeforeSetVariable!=None: #debug ''' self.debug( [ 'The Manager has something before for the managed value', ('self.',self,['ManagingBeforeSetVariable']) ] ) ''' #map set self.ManagedValueVariable['#map@set']( self.ManagingBeforeSetVariable ) #/##########################/ # If the value itself was a set variable # #debug ''' self.debug( [ 'There was a ManagedTempValueVariable here', 'ManagedTempValueVariable!=None is', str(ManagedTempValueVariable!=None) ] ) ''' #Check if ManagedTempValueVariable!=None: #debug ''' self.debug( [ 'We manage with a ManagedValueVariable', 'ManagedTempValueVariable is ', SYS._str(ManagedTempValueVariable) ] ) ''' #set with the value self.ManagedValueVariable['#map@set']( ManagedTempValueVariable ) #/##########################/ # If there are shared after set values # #Check if self.ManagingAfterSetVariable!=None: #debug ''' self.debug( [ 'The Manager has something after for the managed value', ('self.',self,['ManagingAfterSetVariable']) ] ) ''' #map set self.ManagedValueVariable['#map@set']( self.ManagingAfterSetVariable ) else: #/########################/# # just get and update # #debug ''' self.debug( [ 'Ok we just get' ] ) ''' #get self.ManagedValueVariable=self.ManagementDict[ self.ManagingKeyStr ] #debug ''' self.debug( [ 'We maybe update', ('self.',self,['ManagingValueRigidVariable']) ] ) ''' #Check if hasattr( self.ManagingValueRigidVariable, 'items' ) or SYS.getIsTuplesListBool(self.ManagingValueRigidVariable): #Check if self.ManagingWrapBool: #set self.ManagedValueVariable['#map@set']( self.ManagingValueRigidVariable ) #/###################/# # reset rigid variable # #debug ''' self.debug( [ 'We reset the ManagingValueRigidVariable', ('self.',self,['ManagingValueRigidVariable']) ] ) ''' #set self.ManagingValueRigidVariable=None
def do_instance(self): """ """ #Check if self.InstancingIsBool: #Init InstancingClass=None #TuplesList Case if SYS.getIsTuplesListBool(self.InstancingVariable): #debug ''' self.debug('This is a tuples list') ''' if self.InstancingClass==None: #debug ''' self.debug('Find the instancing class') ''' #Definition the KeyStrsList KeyStrsList=SYS.unzip(self.InstancingVariable,[0]) try: InstancingClass=self.InstancingVariable[KeyStrsList.index('InstancingClass')][1] except: pass else: InstancingClass=self.InstancingClass #Check if InstancingClass!=None: #Init self.InstancedVariable=InstancingClass() #Map map( lambda __ItemTuple: self.InstancedVariable.__setattr__(*__ItemTuple), self.InstancingVariable ) #debug ''' self.debug(('vars ',vars(),['InstancedVariable'])) ''' elif hasattr(self.InstancingVariable,'items'): #debug ''' self.debug('This is an itemizing thing') ''' if self.InstancingClass==None: #debug ''' self.debug('Find the instancing class') ''' try: InstancingClass=self.InstancingVariable['InstancingClass'] except: pass else: #Definition InstancingClass=self.InstancingClass if InstancingClass!=None: #Init self.InstancedVariable=InstancingClass() #Map map( lambda __ItemTuple: self.InstancedVariable.__setattr__(*__ItemTuple), self.InstancingVariable.items() ) elif hasattr(self.InstancingVariable,'__dict__'): #Check if self.InstancingClass!=None: #Init self.InstancedVariable=self.InstancingClass()