def do_test(self): #Init in the classed Module if hasattr(self.Module,'TestingPrintIsBool')==False: self.Module.TestingPrintIsBool=True self.Module.TestedOrderedDict=collections.OrderedDict() #Debug ''' print('Tester l 160') print('self.AttestingFolderPathStr is '+self.AttestingFolderPathStr) print('') ''' #set the tests for each asserting function map( lambda __AttestedUnboundMethod: setTestFunctionWithFolderPathStrAndAttestUnboundMethod( self.AttestingFolderPathStr, __AttestedUnboundMethod ), self.AttestedUnboundMethodsList ) #Definition the TestClass class TestClass(unittest.TestCase): #Bind with the Tested object TestedPointer=self #Bound the setUp function #locals().__setitem__(setUp.__name__,setUp) #Bound each testing function for __InstanceVariableedKeyStr,__InstanceVariableedMethod in self.Module.TestedOrderedDict.items(): locals().__setitem__(__InstanceVariableedKeyStr,__InstanceVariableedMethod) try: del TestedKeyStr,TestedMethod except: pass #Give a name TestClass.__name__=SYS.getClassStrWithNameStr(self.NameStr+'Test') #set to the module of the classing class self.Module.TestedClass=TestClass #Definition def test(): #Call to the unittest runner TestLoader=unittest.TestLoader().loadTestsFromTestCase( self.Module.TestedClass ) unittest.TextTestRunner(verbosity=2).run(TestLoader) #Link to the module of the classing class self.Module.test=test
def do_model(self): """ """ #Debug self.debug('model start') #/###################/# # Define the ModeledKeyStr # if self.ModeledDescriptionKeyStr=='': self.ModeledDescriptionKeyStr=self.ModelTagStr #/###################/# # Special case of hdf when we have to define Model Description class # #Check if self.ModelingHdfBool: #import import tables #Definition the DescriptionClass class DescriptionClass(tables.IsDescription): #Add (just like a unique KEY in mysql...) RowInt=tables.Int64Col() #debug self.debug( [ 'We add descriptions in the description Class', ('self.',self,['ModelingDescriptionTuplesList']) ] ) #set the cols in the ModelClass map( lambda __ModelingColumnTuple: DescriptionClass.columns.__setitem__( __ModelingColumnTuple[1], __ModelingColumnTuple[2] ), self.ModelingDescriptionTuplesList ) #Give a name DescriptionClass.__name__=SYS.getClassStrWithNameStr(self.ModelTagStr) #set the ModelClass if self.ModeledDescriptionClassesOrderedDict==None: self.ModeledDescriptionClassesOrderedDict=collections.OrderedDict() self.ModeledDescriptionClassesOrderedDict[self.ModelTagStr]=DescriptionClass #set the ModeledDescriptionClass self.ModeledDescriptionClass=DescriptionClass
def test(_InstanceVariable): #Debug ''' print('Tester l 62') print('_FolderPathStr is '+_FolderPathStr) print('AttestUnboundMethodStr is '+AttestUnboundMethodStr) print('') ''' #Get the AssertedStr File=open(_FolderPathStr+AttestUnboundMethodStr+'.txt','r') AttestStr=File.read() File.close() #Call the attest function to get the TestVariable TestVariable=_AttestUnboundMethod( getattr( SYS, SYS.getClassStrWithNameStr( TestModule.__name__.split('.')[-1] if '.' in TestModule.__name__ else TestModule ) )() ) #Bind with TestStr setting Printer.RepresentingIdBool=False TestStr=Printer.getPrintStr(TestVariable) Printer.RepresentingIdBool=True #Represent maybe if TestModule.TestingPrintIsBool: #debug print("\n###########################################") print("") print('AttestStr is :') print(AttestStr) print("") #debug print('TestStr is :') print(TestStr) print("") #Assert #print("a",AssertingStr) #print("b",_InstanceVariable.TestedPointer.TestStr) #assert _InstanceVariable.assertEqual( #1,1 AttestStr, TestStr )
def getClass(_InstanceVariable,_ClassVariable=None): #Debug ''' print('Classor l 35') print('_ClassVariable is ') print(_ClassVariable) print('') ''' #Check if type(_ClassVariable) in SYS.StrTypesList: if _ClassVariable=="": return _InstanceVariable.__class__ else: return getattr(SYS,SYS.getClassStrWithNameStr(_ClassVariable)) elif _ClassVariable==None: return _InstanceVariable.__class__ else: return _ClassVariable
def do_model(self): """ """ # Debug """ self.debug( [ 'model start', ('self.',self,[ 'ModelMongoBool', 'ModelHdfBool' ]) ] ) """ # /###################/# # Mongo Case # # Check if self.ModelMongoBool: # debug """ self.debug( 'We model mongo here' ) """ # set self.ModeledMongoSuffixStr = self.ModelTagStr + "Collection" # debug """ self.debug( [ ('self.',self,[ 'PymongoneClientVariable', 'ModeledMongoSuffixStr' ] ) ] ) """ # Check if self.ModelDeriveControllerVariable.PymongoneClientVariable == None: # debug """ self.debug('We have to pymongo first...') """ # pymongo self.ModelDeriveControllerVariable.pymongo() # Link self.ModeledMongoTopClientVariable = self.ModelDeriveControllerVariable.PymongoneClientVariable # Check if self.ModeledMongoTopClientVariable != None: # debug """ self.debug( [ 'Looking for names of collections here', ('self.',self,[ 'ModeledMongoTopClientVariable' ]), ] ) """ # /#################/# # Check for the name # # Check if self.ModelDeriveControllerVariable.PymongoingDatabaseStr == "": # set self.ModeledMongoDatabaseKeyStr = self.ModelDeriveControllerVariable.ControlTagStr # set self.ModelDeriveControllerVariable.PymongoingDatabaseStr = self.ModeledMongoDatabaseKeyStr else: # set self.ModeledMongoDatabaseKeyStr = self.ModelDeriveControllerVariable.PymongoingDatabaseStr # set self.ModeledMongoLocalDatabaseVariable = self.ModeledMongoTopClientVariable[ self.ModeledMongoDatabaseKeyStr ] # debug """ self.debug( [ ('self.',self,[ 'ModeledMongoDatabaseKeyStr', 'ModeledMongoLocalDatabaseVariable' ]), "id(self.ModeledMongoLocalDatabaseVariable) is "+str( id(self.ModeledMongoLocalDatabaseVariable)) ] ) """ # set self.ModeledMongoLocalDatabaseVariable.__dict__[ "ParentDerivePymongoer" ] = self.ModelDeriveControllerVariable # alias self.ModelDeriveControllerVariable.Database = self.ModeledMongoLocalDatabaseVariable # debug """ self.debug( [ ('self.',self,[ 'ModeledMongoLocalDatabaseVariable' ]), "'ParentDerivePymongoer' in self.ModeledMongoLocalDatabaseVariable.__dict__", 'ParentDerivePymongoer' in self.ModeledMongoLocalDatabaseVariable.__dict__ ] ) """ # Get and sort self.ModeledMongoKeyStrsList = map( str, sorted( filter( lambda __KeyStr: __KeyStr.endswith(self.ModeledMongoSuffixStr), self.ModeledMongoLocalDatabaseVariable.collection_names(), ) ), ) # debug """ self.debug( [ ('self.',self,[ 'ModeledMongoKeyStrsList' ]) ] ) """ # update self.ModeledMongoCollectionsOrderedDict.update( map( lambda __ModeledKeyStr: ( __ModeledKeyStr, self.ModeledMongoLocalDatabaseVariable[__ModeledKeyStr], ), self.ModeledMongoKeyStrsList, ) ) # debug """ self.debug(("self.",self,[ 'ModeledMongoSuffixStr', 'ModeledMongoKeyStrsList' ])) """ # debug """ self.debug( [ 'ModeledMongoKeyStrsList', 'ModeledMongoSuffixStr', 'ModeledMongoKeyStr' ] ) """ # Get the suffix Strs of all the tables and their index ModeledMongoList = SYS.unzip( map( lambda __StrsList: (__StrsList[1], ModelOrderStr.join(__StrsList[2:])), map( lambda __ModeledMongoKeyStr: __ModeledMongoKeyStr.split(ModelOrderStr), self.ModeledMongoKeyStrsList, ), ), [0, 1], ) # debug """ self.debug(('vars ',vars(),['ModeledHdfList'])) """ # Unpack if it is possible if len(ModeledMongoList) > 0: # Unpack [ModeledMongoIndexIntsTuple, ModeledMongoSuffixStrsList] = ModeledMongoList # debug """ self.debug( [ 'There are already some tables', 'ModeledMongoSuffixStrsList is '+str(ModeledMongoSuffixStrsList), "self.ModeledMongoSuffixStr is "+str( self.ModeledMongoSuffixStr) ] ) """ if self.ModeledMongoSuffixStr not in ModeledMongoSuffixStrsList: # Increment the IndexStr ModeledMongoIndexInt = max(map(int, ModeledMongoIndexIntsTuple)) + 1 # Strify ModeledMongoIndexStr = str(ModeledMongoIndexInt) # debug """ self.debug('IndexStr of this new table is '+str(IndexStr)) """ else: # Get the already setted one ModeledMongoIndexStr = self.ModeledMongoKeyStrsList[ ModeledMongoSuffixStrsList.index(self.ModeledMongoSuffixStr) ].split(ModelOrderStr)[1] # Intify ModeledMongoIndexInt = (int)(ModeledMongoIndexStr) # debug """ self.debug('IndexStr of this not new table is '+str(IndexStr)) """ else: # debug """ self.debug('There are no tables here') """ # set to empty lists [ModeledMongoIndexIntsTuple, ModeledMongoSuffixStrsList] = [[], []] # Init the list ModeledMongoIndexInt = 0 # Strify ModeledMongoIndexStr = "0" # Bind with ModeledHdfKeyStr setting self.ModeledMongoKeyStr = ModelOrderStr + ModeledMongoIndexStr + ModelOrderStr + self.ModeledMongoSuffixStr # set the ModeledInt self.ModeledMongoIndexInt = ModeledMongoIndexInt # debug """ self.debug("self.ModeledMongoKeyStr is "+str(self.ModeledMongoKeyStr)) """ # debug """ self.debug( [ 'Here we create the collection or get it depending if it is new or not', 'self.ModeledMongoKeyStr is '+self.ModeledMongoKeyStr, 'self.ModeledTopFileVariable!=None is '+str(self.ModeledTopFileVariable!=None) ] ) """ # Check if self.ModeledMongoKeyStr != "" and self.ModeledMongoLocalDatabaseVariable != None: # debug """ self.debug( [ ('self.',self,[ 'ModeledMongoKeyStr', 'ModeledMongoKeyStrsList' ] ), 'self.ModeledMongoLocalDatabaseVariable.collection_names() is ', str(self.ModeledMongoLocalDatabaseVariable.collection_names()) ] ) """ # Create the collection if not already if self.ModeledMongoKeyStr not in self.ModeledMongoKeyStrsList: # debug """ self.debug( [ 'The collection not exists', ] ) """ # Create the collections self.ModeledMongoCollection = self.ModeledMongoLocalDatabaseVariable.create_collection( self.ModeledMongoKeyStr ) # Append self.ModeledMongoKeyStrsList.append(self.ModeledMongoKeyStr) else: # debug """ self.debug( [ 'The collection exists', ] ) """ # Else just get it self.ModeledMongoCollection = self.ModeledMongoLocalDatabaseVariable[self.ModeledMongoKeyStr] # set the in the ModeledMongoCollectionsOrderedDict self.ModeledMongoCollectionsOrderedDict[self.ModeledMongoKeyStr] = self.ModeledMongoCollection # debug """ self.debug("self.ModeledMongoCollectionsOrderedDict is "+str(self.ModeledMongoCollectionsOrderedDict)) """ # debug """ self.debug( [ 'Table is done here for mongo...', ('self.',self,[ 'ModeledMongoCollection', 'ModeledMongoTopDatabaseVariable' ] ) ] ) """ # /###################/# # Hdf Case # # Check if self.ModelHdfBool: # /################/# # Model is to modify modeling description so keep an old version of this before # # debug """ self.debug( [ 'Keep maybe a copy of ModelingDescriptionTuplesList', ('self.',self,[ 'ModelingDescriptionTuplesList', 'ModelDescriptionTuplesList' ]) ] ) """ # keep a memory if self.ModelDescriptionTuplesList == None: # copy self.ModelDescriptionTuplesList = copy.deepcopy(self.ModelingDescriptionTuplesList) # /################/# # Pick the shape ints and their get key strs # # debug """ self.debug( [ 'We model shape here', ("self.",self,['ModelDimensionTuplesList']) ] ) """ # Check if self.ModelDimensionTuplesList != None and len(self.ModelDimensionTuplesList) > 0: # set [self.ModeledDescriptionGetKeyStrsList, ModeledDescriptionDimensionGetTuplesList] = SYS.unzip( self.ModelDimensionTuplesList, [0, 1] ) # list self.ModeledDescriptionGetKeyStrsList = list(self.ModeledDescriptionGetKeyStrsList) # debug """ self.debug( [ 'ModeledDescriptionDimensionGetTuplesList is ', str(ModeledDescriptionDimensionGetTuplesList) ] ) """ # unzip self.ModeledDescriptionDimensionGetKeyStrsListsList = SYS.unzip( list(ModeledDescriptionDimensionGetTuplesList), [1] ) # debug """ self.debug( [ ('self.',self,['ModeledDescriptionDimensionGetKeyStrsListsList']) ] ) """ # /###################/# # Check the dimension that are not defined or equal to zero # set them to one # map map self.ModeledDescriptionDimensionIntsListsList = map( lambda __ModeledDescriptionDimensionGetKeyStrsList: map( lambda __ModeledDescriptionDimensionGetKeyStr, __ShapeInt: self.ModelDeriveControllerVariable.set( __ModeledDescriptionDimensionGetKeyStr, __ShapeInt + 1 )[ __ModeledDescriptionDimensionGetKeyStr ] if __ShapeInt == 0 else __ShapeInt, __ModeledDescriptionDimensionGetKeyStrsList, map( lambda __ModeledDescriptionDimensionGetKeyStr: self.ModelDeriveControllerVariable[ __ModeledDescriptionDimensionGetKeyStr ], __ModeledDescriptionDimensionGetKeyStrsList, ), ), self.ModeledDescriptionDimensionGetKeyStrsListsList, ) # get the corresponding real dimensions """ self.ModeledDescriptionDimensionIntsListsList=map( lambda __ModeledDescriptionDimensionGetKeyStrsList: self.ModelDeriveControllerVariable[ Getter.GetMapStr ]( *__ModeledDescriptionDimensionGetKeyStrsList ).ItemizedMapValueVariablesList, self.ModeledDescriptionDimensionGetKeyStrsListsList ) """ # debug """ self.debug( [ ('self.',self,[ 'ModeledDescriptionDimensionIntsListsList' ]) ] ) """ else: # Default self.ModeledDescriptionGetKeyStrsList = [] self.ModeledDimensionGetKeyStrsList = [] self.ModeledDescriptionDimensionGetKeyStrsListsList = [] # debug """ self.debug( [ ("self.",self,[ 'ModeledDescriptionGetKeyStrsList', 'ModeledDescriptionDimensionGetKeyStrsListsList', 'ModeledDescriptionDimensionIntsListsList' ]) ] ) """ # /################/# # Find where in the description takes list it has to be modified # # Definition ModeledGetKeyStrsList = SYS.unzip(self.ModelingDescriptionTuplesList, [0]) # set self.ModeledShapeIndexIntsList = map( lambda __ModeledDescriptionGetKeyStr: ModeledGetKeyStrsList.index(__ModeledDescriptionGetKeyStr), self.ModeledDescriptionGetKeyStrsList, ) # debug """ self.debug( [ 'We know the index of the shape description tuples', ('self.',self,['ModeledShapeIndexIntsList']) ] ) """ # /################/# # set flat all the get key str for the shaping int # # Check if self.ModelDeriveControllerVariable != None: # debug """ self.debug( [ 'We flat the DimensionGetKeyStrsLists', ('self.',self,[ 'ModeledDescriptionDimensionGetKeyStrsListsList' ]) ] ) """ # Flat and set self.ModeledDimensionGetKeyStrsList = list( set(SYS.flat(self.ModeledDescriptionDimensionGetKeyStrsListsList)) ) # debug """ self.debug( [ ('self.',self,[ 'ModeledDimensionGetKeyStrsList' ]) ] ) """ # Pick self.ModeledDimensionIntsList = self.ModelDeriveControllerVariable[Getter.GetMapStr]( *self.ModeledDimensionGetKeyStrsList ).ItemizedMapValueVariablesList else: # Default self.ModeledDimensionIntsList = [] # /################/# # map a join str with this # # debug """ self.debug( [ 'No we set the ModeledShapeStr', ("self.",self,[ 'ModeledDimensionGetKeyStrsList', 'ModeledDimensionIntsList' ]) ] ) """ # Bind with ModeledShapeStr setting self.ModeledShapeStr = ModelJoinStr.join( map( lambda __ModeledDescriptionGetKeyStr, __ModeledDimensionVariable: ModelJoinStr + str(__ModeledDescriptionGetKeyStr) + ModelDimensionStr + str(__ModeledDimensionVariable), self.ModeledDimensionGetKeyStrsList, self.ModeledDimensionIntsList, ) ) # debug """ self.debug( [ ('self.',self,['ModeledShapeStr']) ] ) """ # /#################/# # Adapt the name of the description model given the shape # # debug """ self.debug( [ 'Ok we have shaped', ('self.',self,['ModeledShapeStr']) ] ) """ # Get the new ModeledKeyStr if self.ModeledShapeStr != "": # debug """ self.debug( [ 'We set the new ModeledHdfSuffixStr', ('self.',self,['ModeledShapeStr','ModelTagStr']) ] ) """ # set self.ModeledHdfSuffixStr = self.ModeledShapeStr + ModelJoinStr + self.ModelTagStr else: # set self.ModeledHdfSuffixStr = self.ModelTagStr # debug """ self.debug( [ 'We have set the new ModeledHdfSuffixStr', ('self.',self,[ 'ModeledShapeStr', 'ModeledHdfSuffixStr' ]) ] ) """ # /#################/# # Set the good format for the Description tuples list # # Unnzip ModeledGetKeyStrsList = SYS.unzip(self.ModelingDescriptionTuplesList, [0]) # debug """ self.debug( [ ('Now change the shape of the shaping cols'), ('self.',self,[ 'ModelingDescriptionTuplesList', 'ModeledShapeIndexIntsList' ]) ] ) """ # map ModeledShapeDescriptionTuplesList = map( self.ModelingDescriptionTuplesList.__getitem__, self.ModeledShapeIndexIntsList ) # debug """ self.debug( [ 'ModeledShapeDescriptionTuplesList is '+str( ModeledShapeDescriptionTuplesList ), ('self.',self,['ModeledDescriptionDimensionIntsListsList']) ] ) """ # map ModeledShapeDescriptionTuplesList = map( lambda __ModeledShapeDescriptionTuple, __ModeledDescriptionDimensionIntsList: ( __ModeledShapeDescriptionTuple[0], __ModeledShapeDescriptionTuple[1], __ModeledShapeDescriptionTuple[2][0](shape=__ModeledDescriptionDimensionIntsList), ), ModeledShapeDescriptionTuplesList, self.ModeledDescriptionDimensionIntsListsList, ) # debug """ self.debug( [ 'ModeledShapeDescriptionTuplesList is '+str( ModeledShapeDescriptionTuplesList) ] ) """ # set the shaping cols map( lambda __ModeledIndexInt, __ModeledModelingDescriptionTuple: self.ModelingDescriptionTuplesList.__setitem__( __ModeledIndexInt, __ModeledModelingDescriptionTuple ), self.ModeledShapeIndexIntsList, ModeledShapeDescriptionTuplesList, ) # debug """ self.debug( [ "After the shape we check for the modeling description", ('self.',self,[ 'ModelingDescriptionTuplesList', 'ModelKeyStrsList' ] ) ] ) """ # /###################/# # Check maybe the Description was not yet done although there are ModelKeystrs # if len(self._ModelKeyStrsList) > len(self.ModelingDescriptionTuplesList): # bind self.propertize_setModelKeyStrsList(self._ModelKeyStrsList) # debug """ self.debug( [ "After the bind", ('self.',self,[ 'ModelingDescriptionTuplesList', 'ModelKeyStrsList' ] ) ] ) """ # /###################/# # Define the Description # # import import tables # Definition the DescriptionClass class DescriptionClass(tables.IsDescription): # Add (just like a unique KEY in mysql...) RowInt = tables.Int64Col() # debug """ self.debug( [ 'We add descriptions in the description Class', ('self.',self,['ModelingDescriptionTuplesList']) ] ) """ # set the cols in the ModelClass map( lambda __ModelingColumnTuple: DescriptionClass.columns.__setitem__( __ModelingColumnTuple[1], __ModelingColumnTuple[2] ), self.ModelingDescriptionTuplesList, ) # Give a name DescriptionClass.__name__ = SYS.getClassStrWithNameStr(self.ModelTagStr) # set the ModelClass if self.ModeledDescriptionClassesOrderedDict == None: self.ModeledDescriptionClassesOrderedDict = collections.OrderedDict() self.ModeledDescriptionClassesOrderedDict[self.ModelTagStr] = DescriptionClass # set the ModeledDescriptionClass self.ModeledDescriptionClass = DescriptionClass # /###################/# # Begin to set the hdf file # first look if we have to hdformat # # debug """ self.debug( [ 'We tabular for hdf here...', 'self.ModelDeriveControllerVariable.HdformatedFileVariable is ', str(self.ModelDeriveControllerVariable.HdformatedFileVariable) ] ) """ # set if self.ModeledHdfSuffixStr == "": self.ModeledHdfSuffixStr = self.ModelTagStr + "Table" # Check if self.ModelDeriveControllerVariable.HdformatedFileVariable == None: # /##################/# # If it is the top controller we have to hdformat # # debug """ self.debug( [ 'Look if the controller is the top one', 'self.ModelDeriveControllerVariable.ParentTopDeriveTeamerVariable==self.ModelDeriveControllerVariable', str(self.ModelDeriveControllerVariable.ParentTopDeriveTeamerVariable==self.ModelDeriveControllerVariable) ] ) """ # Check if ( self.ModelDeriveControllerVariable.ParentTopDeriveTeamerVariable == self.ModelDeriveControllerVariable ): # /##################/# # Set a default name # # Check if self.ModelDeriveControllerVariable.HdformatingFileKeyStr == "": # set self.ModelDeriveControllerVariable.HdformatingFileKeyStr = ( self.ModelDeriveControllerVariable.ControlTagStr + ".hdf5" ) # /##################/# # hdformat # # debug """ self.debug( [ 'We have to make hdformat the controller first...', ('self.ModelDeriveControllerVariable.', self.ModelDeriveControllerVariable, [ 'ControlTagStr' ]) ] ) """ # Hdformat self.ModelDeriveControllerVariable.hdformat() # debug """ self.debug( [ 'Ok the top controller has hdformated', ('self.ModelDeriveControllerVariable.', self.ModelDeriveControllerVariable, [ 'HdformatedFileVariable', 'ControlTagStr' ]) ] ) """ else: # /##################/# # If it is not the top we have just # to alias with the one of the top # # alias self.ModelDeriveControllerVariable.HdformatedFileVariable = ( self.ParentTopDeriveTeamerVariable.HdformatedFileVariable ) # /##################/# # Set the group path str to trigger # a set in the hdf # debug """ self.debug( [ 'We set in the hdf the group branch' ] ) """ # Set self.ModelDeriveControllerVariable.HdfGroupPathStr = self.ModelDeriveControllerVariable.ControlTagStr # debug """ self.debug( [ 'Ok the group is setted' ] ) """ # Link self.ModeledHdfTopFileVariable = self.ModelDeriveControllerVariable.HdformatedFileVariable # debug """ self.debug( [ 'Ok the hdf file is setted', ('self.',self,[ 'ModeledHdfTopFileVariable' ]) ] ) """ # /#################/# # Check for all the tables already defined here # # Check if self.ModeledHdfTopFileVariable != None: # debug """ self.debug( [ 'Looking for names of tables here', ( 'self.ModelDeriveControllerVariable.', self.ModelDeriveControllerVariable, ['HdfGroupPathStr'] ) ] ) """ # Definition Modeled attributes self.ModeledHdfGroupVariable = self.ModeledHdfTopFileVariable.getNode( self.ModelDeriveControllerVariable.HdfGroupPathStr ) # debug """ self.debug( [ ('looking for tables with the same Model Tag Str as : '), ('self.',self,['ModelTagStr']) ] ) """ # Get and sort self.ModeledHdfKeyStrsList = sorted( filter( lambda __KeyStr: __KeyStr.endswith(self.ModelTagStr), self.ModeledHdfGroupVariable._v_leaves.keys(), ) ) # update self.ModeledHdfTablesOrderedDict.update( map( lambda __ModeledKeyStr: ( __ModeledKeyStr, self.ModeledHdfGroupVariable._f_getChild(__ModeledKeyStr), ), self.ModeledHdfKeyStrsList, ) ) # debug """ self.debug( [ ("self.",self,[ 'ModeledHdfTablesOrderedDict' ]) ] ) """ # /################/# # Refind all the names of the tables # # debug """ self.debug( ('self.',self,[ 'ModeledHdfKeyStrsList', 'ModeledHdfSuffixStr', 'ModeledHdfKeyStr' ]) ) """ # Get the suffix Strs of all the tables and their index ModeledHdfList = SYS.unzip( map( lambda __StrsList: (__StrsList[1], ModelOrderStr.join(__StrsList[2:])), map(lambda __ModeledHdfKeyStr: __ModeledHdfKeyStr.split(ModelOrderStr), self.ModeledHdfKeyStrsList), ), [0, 1], ) # debug """ self.debug( [ 'All the corresponding table models are ', ('vars()[\'',vars(),['ModeledHdfList'],"\']") ] ) """ # /##################/# # Find if there are already some tables here and deduce the index of the table # # Unpack if it is possible if len(ModeledHdfList) > 0: # Unpack [ModeledHdfIndexIntsTuple, ModeledHdfSuffixStrsList] = ModeledHdfList # debug """ self.debug( [ 'There are already some tables', 'ModeledHdfSuffixStrsList is '+str(ModeledHdfSuffixStrsList), "self.ModeledHdfSuffixStr is "+str( self.ModeledHdfSuffixStr) ] ) """ if self.ModeledHdfSuffixStr not in ModeledHdfSuffixStrsList: # Increment the IndexStr ModeledHdfIndexInt = max(map(int, ModeledHdfIndexIntsTuple)) + 1 # Strify ModeledHdfIndexStr = str(ModeledHdfIndexInt) # debug """ self.debug('IndexStr of this new table is '+str(IndexStr)) """ else: # Get the already setted one ModeledHdfIndexStr = self.ModeledHdfKeyStrsList[ ModeledHdfSuffixStrsList.index(self.ModeledHdfSuffixStr) ].split(ModelOrderStr)[1] # Intify ModeledHdfIndexInt = (int)(ModeledHdfIndexStr) # debug """ self.debug('IndexStr of this not new table is '+str(IndexStr)) """ else: # debug """ self.debug('There are no tables here') """ # set to empty lists [ModeledHdfIndexIntsTuple, ModeledHdfSuffixStrsList] = [[], []] # Init the list ModeledHdfIndexInt = 0 # Strify ModeledHdfIndexStr = "0" # /##################/# # set the table key str # # debug """ self.debug( [ 'We set the table key str', ('self.',self,[ 'ModeledHdfSuffixStr' ]), 'ModeledHdfIndexStr is '+str(ModeledHdfIndexStr) ] ) """ # Bind with ModeledHdfKeyStr setting self.ModeledHdfKeyStr = ModelOrderStr + ModeledHdfIndexStr + ModelOrderStr + self.ModeledHdfSuffixStr # set the ModeledInt self.ModeledHdfIndexInt = ModeledHdfIndexInt # debug """ self.debug( [ 'Ok we have setted which hdf table', ('self.',self,[ 'ModeledHdfKeyStr', 'ModeledHdfIndexInt' ]), 'Now we create the table, or get it, depending if it is new or not', ('self.',self,[ 'ModeledHdfKeyStr', 'ModeledHdfTopFileVariable' ]) ] ) """ # Check if self.ModeledHdfKeyStr != "" and self.ModeledHdfTopFileVariable != None: # debug """ self.debug( [ ('self.',self,[ 'ModeledHdfKeyStr', 'ModeledHdfKeyStrsList' ]) ] ) """ # Create the Table if not already if self.ModeledHdfKeyStr not in self.ModeledHdfKeyStrsList: # debug """ self.debug( [ 'The table not exists', ] ) """ # Create the Table in the hdf5 self.ModeledHdfTable = self.ModeledHdfTopFileVariable.create_table( self.ModeledHdfGroupVariable, self.ModeledHdfKeyStr, self.ModeledDescriptionClass, self.ModeledDescriptionClass.__doc__ if self.ModeledDescriptionClass.__doc__ != None else "This is the " + self.ModeledDescriptionClass.__name__, ) # Append self.ModeledHdfKeyStrsList.append(self.ModeledHdfKeyStr) else: # debug """ self.debug( [ 'The table exists', "self.ModeledGroupVariable is "+str(self.ModeledGroupVariable) ] ) """ # Else just get it self.ModeledHdfTable = self.ModeledHdfGroupVariable._f_getChild(self.ModeledHdfKeyStr) # set the in the TablesOrderedDict self.ModeledHdfTablesOrderedDict[self.ModeledHdfKeyStr] = self.ModeledHdfTable # debug """ self.debug("self.ModeledHdfTablesOrderedDict is "+str( self.ModeledHdfTablesOrderedDict)) """ # debug """
def do__class(self): #Definition the MethodsList ClassedFunctionsList=SYS._filter( lambda __ListedVariable: type(__ListedVariable).__name__=="function" if hasattr(__ListedVariable,'__name__') else False, self.DoClass.__dict__.values() ) #debug ''' print('l 66 Classer') print("ClassedFunctionsList is ",WatchedFunctionsList) print('Set all the mimick methods') print('') ''' #/###################/# # Mimic all that you can find # #Get all the hooking methods ClassedMimickFunctionsList=SYS._filter( lambda __ListedVariable: __ListedVariable.__name__.startswith( Mimicker.MimickingWrapPrefixStr ) if hasattr(__ListedVariable,'__name__') else False, ClassedFunctionsList ) #debug ''' print('l 82 Classer') print("ClassedMimickFunctionsList is ",ClassedMimickFunctionsList) print('') ''' #map map( lambda __ClassedMimickFunction: self.mimic( Mimicker.MimickingWrapPrefixStr.join( __ClassedMimickFunction.__name__.split( Mimicker.MimickingWrapPrefixStr)[1:] ) ), ClassedMimickFunctionsList ) #/###################/# # Set the watch methods # #debug ''' print('l 104 Classer') print('set the watch functions') print('self.ClassingWatchMethodStrsList is ',self.ClassingWatchMethodStrsList) print('self.DoClass.DoMethodStr is ',self.DoClass.DoMethodStr) print('') ''' #map map( lambda __ClassingWatchUnboundMethodStr: self.watch( True, **{'ObservingWrapMethodStr':__ClassingWatchUnboundMethodStr} ), self.ClassingWatchMethodStrsList ) #/###################/# # Set the switch methods # #debug ''' print('l 104 Classer') print('set the switch functions') print('self.ClassingSwitchMethodStrsList is ',self.ClassingSwitchMethodStrsList) print('self.DoClass.DoMethodStr is ',self.DoClass.DoMethodStr) print('') ''' #map map( lambda __ClassingSwitchUnboundMethodStr: self.switch( True, __ClassingSwitchUnboundMethodStr ), self.ClassingSwitchMethodStrsList ) #/###################/# # Check for overriden propertize_ methods # #Debug ''' print('Classer l 125') print('Check for overriden propertize_ methods ') print('self.DoClass.InspectMethodDict') print(self.DoClass.InspectMethodDict) print('') ''' #filter ClassedPropertyNewMethodDict=dict( SYS._filter( lambda __MethodItemTuple: __MethodItemTuple[0].startswith( Propertiser.PropertyPrefixStr ) and ( SYS.getNewMethodBool(self.DoClass,__MethodItemTuple[0]) #getattr( # self.DoClass.__bases__[0], # __MethodItemTuple[0] #)!=__MethodItemTuple[1] #if hasattr(self.DoClass.__bases__[0], # __MethodItemTuple[0] #) else True ), self.DoClass.InspectMethodDict.items() ) ) #Debug ''' print('Classer l 147') print('self.DoClass is ') print(self.DoClass) print('ClassedPropertyNewMethodDict is') print(SYS.indent(ClassedPropertyNewMethodDict)) print('') ''' #map ClassedPropertyKeyStrsList=map( lambda __PropertizedKeyStr: SYS.deprefix( __PropertizedKeyStr, Propertiser.PropertyPrefixStr )[3:], ClassedPropertyNewMethodDict.keys() ) #map reset the properties map( lambda __PropertyKeyStr: setattr( self.DoClass, __PropertyKeyStr, property( getattr( self.DoClass, Propertiser.PropertyPrefixStr+'get'+__PropertyKeyStr ), getattr( self.DoClass, Propertiser.PropertyPrefixStr+'set'+__PropertyKeyStr ), getattr( self.DoClass, Propertiser.PropertyPrefixStr+'del'+__PropertyKeyStr ) ) ), ClassedPropertyKeyStrsList ) #/###################/# # Set maybe a structure # #Check if self.ClassingStructureVariable!=None: #Check if hasattr( self.ClassingStructureVariable,'items' ): ClassedStructureVariable=self.ClassingStructureVariable.items() else: ClassedStructureVariable=self.ClassingStructureVariable #debug ''' print('Classer l 241') print('We structure here') print('self.ClassingStructureVariable is ') print(self.ClassingStructureVariable) print('') ''' #map add the sing plurals map( lambda __ItemTuple: SYS.addSingPlural( *__ItemTuple ), ClassedStructureVariable ) #Define a class class StructureClass(SYS.StructurerClass):pass StructureClass.__name__=SYS.getClassStrWithNameStr(self.DoClass.NameStr+'sStructurer') StructureClass.ManagingValueClass=self.DoClass #set setattr( self.Module, StructureClass.__name__, StructureClass ) #dict ClassesDict=dict( map( lambda __ItemTuple: (__ItemTuple[1],StructureClass), ClassedStructureVariable ) ) #map if self.DoClass.TeamingClassesDict==None: self.DoClass.TeamingClassesDict=ClassesDict else: self.DoClass.TeamingClassesDict.update( ClassesDict )
def do_imitate(self): #Debug ''' print('l. 63 Imitater') print('self.ImitatingFunction is ',self.ImitatingFunction) print('') ''' #Definitions ImitatedDoMethodStr=self.ImitatingFunction.__name__ ImitatedDoStr=ImitatedDoMethodStr[0].upper()+ImitatedDoMethodStr[1:] ImitatedDoerStr=Doer.getDoerStrWithDoStr(ImitatedDoStr) #Debug ''' print('ImitatedDoMethodStr is ',ImitatedDoMethodStr) print('ImitatedDoStr is ',ImitatedDoStr) print('ImitatedDoerStr is ',ImitatedDoerStr) print('') ''' #Definitions ImitatedModule=getattr(SYS,ImitatedDoerStr) ImitatedClass=getattr(ImitatedModule,SYS.getClassStrWithNameStr(ImitatedDoerStr)) ImitatedDoneExecStr=getattr( ImitatedClass, ImitatedClass.NameStr+'DoneExecStr' ).replace('def DoerFunction','def ImitaterFunction') #Define def imitateDo(_InstanceVariable,*_LiargVariablesList,**_KwargVariablesDict): #Debug ''' print('Imitater l.93 inside of the function imitateDo') print('_InstanceVariable is ',_InstanceVariable) print('_LiargVariablesList is ',_LiargVariablesList) print('_KwargVariablesDict is ',_KwargVariablesDict) print('') ''' if len(_KwargVariablesDict)>0: #group by [ImitatedItemTuplesList,ImitatedNotItemTuplesList]=SYS.groupby( lambda __ItemTuple:hasattr(_InstanceVariable,__ItemTuple[0]), _KwargVariablesDict.items() ) #Debug ''' print('ImitatedItemTuplesList is ',ImitatedItemTuplesList) print('ImitatedNotItemTuplesList is ',ImitatedNotItemTuplesList) print('') ''' #set in the instance the corresponding kwarged arguments map( lambda __ItemTuple: #set direct explicit attributes _InstanceVariable.__setattr__(*__ItemTuple), ImitatedItemTuplesList ) #Define ImitatedKwargDict=dict(ImitatedNotItemTuplesList) else: #Define ImitatedKwargDict={} #Init ImitatedOutputVariable=None #Debug ''' print('l.141 Imitater') print('self.ImitatingFunction is ',self.ImitatingFunction) print('ImitatedKwargDict is ',ImitatedKwargDict) print('') ''' #call the imitated function if len(ImitatedKwargDict)>0: ImitatedOutputVariable=self.ImitatingFunction( _InstanceVariable, *_LiargVariablesList, **ImitatedKwargDict ) else: ImitatedOutputVariable=self.ImitatingFunction( _InstanceVariable, *_LiargVariablesList ) #Check if ImitatedClass.DoingGetBool==False: #Return return _InstanceVariable else: #Return the return ImitatedOutputVariable #Link ImitatedFunctionKeyStr='imitate'+ImitatedDoStr+'With'+inspect.getmodule( self.ImitatingFunction ).__name__.split('.')[-1] if hasattr(ImitatedClass,ImitatedFunctionKeyStr)==False: setattr(ImitatedClass,ImitatedFunctionKeyStr,imitateDo) else: ImitatedLastInt=sorted( map( lambda __MethodKeyStr: (int)(__MethodKeyStr.split('_')[-1]), SYS._filter( lambda __KeyStr: __KeyStr.startswith(ImitatedFunctionKeyStr), ImitatedClass.__dict__.keys() ) ) )[-1] setattr(ImitatedClass,ImitatedFunctionKeyStr+'_'+str(ImitatedLastInt),imitateDo) #Add to the ImitatedDoneExecStr ImitatedDoneExecStr+='\n\treturn _InstanceVariable.'+ImitatedFunctionKeyStr+'(*_LiargVariablesList,**_KwargVariablesDict)' #Debug ''' print('ImitatedDoneExecStr is ') print(ImitatedDoneExecStr) print('') ''' #exec six.exec_(ImitatedDoneExecStr) #set the name locals()['ImitaterFunction'].__name__=self.__class__.NameStr+Doer.DoingDecorationStr+ImitatedDoMethodStr #Link self.ImitatedFunction=locals()['ImitaterFunction']
def do_model(self): """ """ #Debug self.debug('model start') #/###################/# # Define the ModeledKeyStr # if self.ModeledDescriptionKeyStr=='': self.ModeledDescriptionKeyStr=self.ModelTagStr #/###################/# # Mongo Case # #Check if self.ModelingMongoBool: #debug ''' self.debug( 'We model mongo here' ) ''' #set self.ModeledMongoSuffixStr=self.ModelTagStr+'Collection' #debug ''' self.debug( [ ('self.',self,[ 'PymongoneClientVariable', 'ModeledMongoSuffixStr' ] ) ] ) ''' #Check if self.ModelDeriveControllerVariable.PymongoneClientVariable==None: #debug ''' self.debug('We have to pymongo first...') ''' #pymongo self.ModelDeriveControllerVariable.pymongo() #Link self.ModeledMongoTopClientVariable=self.ModelDeriveControllerVariable.PymongoneClientVariable #Check if self.ModeledMongoTopClientVariable!=None: #debug ''' self.debug( [ 'Looking for names of collections here', ('self.',self,[ 'ModeledMongoTopClientVariable' ]), ] ) ''' #set self.ModeledMongoDatabaseKeyStr=self.ModelDeriveControllerVariable.ControlModelStr #set self.ModelDeriveControllerVariable.PymongoingDatabaseKeyStr=self.ModeledMongoDatabaseKeyStr #set self.ModeledMongoLocalDatabaseVariable=self.ModeledMongoTopClientVariable[ self.ModeledMongoDatabaseKeyStr ] #debug ''' self.debug( [ ('self.',self,[ 'ModeledMongoDatabaseKeyStr', 'ModeledMongoLocalDatabaseVariable' ]), "id(self.ModeledMongoLocalDatabaseVariable) is "+str( id(self.ModeledMongoLocalDatabaseVariable)) ] ) ''' #set self.ModeledMongoLocalDatabaseVariable.__dict__[ 'ParentDerivePymongoer' ]=self.ModelDeriveControllerVariable #alias self.ModelDeriveControllerVariable.Database=self.ModeledMongoLocalDatabaseVariable #debug ''' self.debug( [ ('self.',self,[ 'ModeledMongoLocalDatabaseVariable' ]), "'ParentDerivePymongoer' in self.ModeledMongoLocalDatabaseVariable.__dict__", 'ParentDerivePymongoer' in self.ModeledMongoLocalDatabaseVariable.__dict__ ] ) ''' #Get and sort self.ModeledMongoKeyStrsList=map( str, sorted( filter( lambda __KeyStr: __KeyStr.endswith( self.ModeledMongoSuffixStr ), self.ModeledMongoLocalDatabaseVariable.collection_names() ) ) ) #debug ''' self.debug( [ ('self.',self,[ 'ModeledMongoKeyStrsList' ]) ] ) ''' #update self.ModeledMongoCollectionsOrderedDict.update( map( lambda __ModeledKeyStr: ( __ModeledKeyStr, self.ModeledMongoLocalDatabaseVariable[ __ModeledKeyStr ] ), self.ModeledMongoKeyStrsList ) ) #debug ''' self.debug(("self.",self,[ 'ModeledMongoSuffixStr', 'ModeledMongoKeyStrsList' ])) ''' #debug ''' self.debug( [ 'ModeledMongoKeyStrsList', 'ModeledMongoSuffixStr', 'ModeledMongoKeyStr' ] ) ''' #Get the suffix Strs of all the tables and their index ModeledMongoList=SYS.unzip(map( lambda __StrsList: ( __StrsList[1], ModelingOrderStr.join(__StrsList[2:]) ), map( lambda __ModeledMongoKeyStr: __ModeledMongoKeyStr.split(ModelingOrderStr), self.ModeledMongoKeyStrsList ) ),[0,1] ) #debug ''' self.debug(('vars ',vars(),['ModeledHdfList'])) ''' #Unpack if it is possible if len(ModeledMongoList)>0: #Unpack [ModeledMongoIndexIntsTuple,ModeledMongoSuffixStrsList]=ModeledMongoList #debug ''' self.debug( [ 'There are already some tables', 'ModeledMongoSuffixStrsList is '+str(ModeledMongoSuffixStrsList), "self.ModeledMongoSuffixStr is "+str( self.ModeledMongoSuffixStr) ] ) ''' if self.ModeledMongoSuffixStr not in ModeledMongoSuffixStrsList: #Increment the IndexStr ModeledMongoIndexInt=max(map(int,ModeledMongoIndexIntsTuple))+1 #Strify ModeledMongoIndexStr=str(ModeledMongoIndexInt) #debug ''' self.debug('IndexStr of this new table is '+str(IndexStr)) ''' else: #Get the already setted one ModeledMongoIndexStr=self.ModeledMongoKeyStrsList[ ModeledMongoSuffixStrsList.index(self.ModeledMongoSuffixStr) ].split(ModelingOrderStr)[1] #Intify ModeledMongoIndexInt=(int)(ModeledMongoIndexStr) #debug ''' self.debug('IndexStr of this not new table is '+str(IndexStr)) ''' else: #debug ''' self.debug('There are no tables here') ''' #set to empty lists [ModeledMongoIndexIntsTuple,ModeledMongoSuffixStrsList]=[[],[]] #Init the list ModeledMongoIndexInt=0 #Strify ModeledMongoIndexStr="0" #Bind with ModeledHdfKeyStr setting self.ModeledMongoKeyStr=ModelingOrderStr+ModeledMongoIndexStr+ModelingOrderStr+self.ModeledMongoSuffixStr #set the ModeledInt self.ModeledMongoIndexInt=ModeledMongoIndexInt #debug ''' self.debug("self.ModeledMongoKeyStr is "+str(self.ModeledMongoKeyStr)) ''' #debug ''' self.debug( [ 'Here we create the collection or get it depending if it is new or not', 'self.ModeledMongoKeyStr is '+self.ModeledMongoKeyStr, 'self.ModeledTopFileVariable!=None is '+str(self.ModeledTopFileVariable!=None) ] ) ''' #Check if self.ModeledMongoKeyStr!="" and self.ModeledMongoLocalDatabaseVariable!=None: #debug ''' self.debug( [ ('self.',self,[ 'ModeledMongoKeyStr', 'ModeledMongoKeyStrsList' ] ), 'self.ModeledMongoLocalDatabaseVariable.collection_names() is ', str(self.ModeledMongoLocalDatabaseVariable.collection_names()) ] ) ''' #Create the collection if not already if self.ModeledMongoKeyStr not in self.ModeledMongoKeyStrsList: #debug ''' self.debug( [ 'The collection not exists', ] ) ''' #Create the collections self.ModeledMongoCollection=self.ModeledMongoLocalDatabaseVariable.create_collection( self.ModeledMongoKeyStr ) #Append self.ModeledMongoKeyStrsList.append(self.ModeledMongoKeyStr) else: #debug ''' self.debug( [ 'The collection exists', ] ) ''' #Else just get it self.ModeledMongoCollection=self.ModeledMongoLocalDatabaseVariable[ self.ModeledMongoKeyStr ] #set the in the ModeledMongoCollectionsOrderedDict self.ModeledMongoCollectionsOrderedDict[ self.ModeledMongoKeyStr ]=self.ModeledMongoCollection #debug ''' self.debug("self.ModeledMongoCollectionsOrderedDict is "+str(self.ModeledMongoCollectionsOrderedDict)) ''' #debug ''' self.debug( [ 'Table is done here for mongo...', ('self.',self,[ 'ModeledMongoCollection', 'ModeledMongoTopDatabaseVariable' ] ) ] ) ''' #/###################/# # Hdf Case # #Check if self.ModelingHdfBool: #/###################/# # Define the Description # #import import tables #Definition the DescriptionClass class DescriptionClass(tables.IsDescription): #Add (just like a unique KEY in mysql...) RowInt=tables.Int64Col() #debug self.debug( [ 'We add descriptions in the description Class', ('self.',self,['ModelingDescriptionTuplesList']) ] ) #set the cols in the ModelClass map( lambda __ModelingColumnTuple: DescriptionClass.columns.__setitem__( __ModelingColumnTuple[1], __ModelingColumnTuple[2] ), self.ModelingDescriptionTuplesList ) #Give a name DescriptionClass.__name__=SYS.getClassStrWithNameStr(self.ModelTagStr) #set the ModelClass if self.ModeledDescriptionClassesOrderedDict==None: self.ModeledDescriptionClassesOrderedDict=collections.OrderedDict() self.ModeledDescriptionClassesOrderedDict[self.ModelTagStr]=DescriptionClass #set the ModeledDescriptionClass self.ModeledDescriptionClass=DescriptionClass #debug ''' self.debug('We tabular for hdf here...') ''' #set self.ModeledHdfSuffixStr=self.ModelTagStr+'Table' #Check if self.ModelDeriveControllerVariable.HdformatedFileVariable==None: #Check if self.ModelDeriveControllerVariable.HdformatingFileKeyStr=='': #set self.ModelDeriveControllerVariable.HdformatingFileKeyStr=self.ModelDeriveControllerVariable.ControlModelStr+'.hdf5' #debug ''' self.debug( [ 'We have to hdformat first...', 'self.ModelDeriveControllerVariable.HdformatingFileKeyStr is ', self.ModelDeriveControllerVariable.HdformatingFileKeyStr ] ) ''' #Hdformat self.ModelDeriveControllerVariable.hdformat() #Set self.ModelDeriveControllerVariable.HdfGroupPathStr=self.ModelDeriveControllerVariable.ControlModelStr #Link self.ModeledHdfTopFileVariable=self.ModelDeriveControllerVariable.HdformatedFileVariable #debug ''' self.debug(('self.',self,[ 'ModeledHdfTopFileVariable' ])) ''' #/#################/# # Check for all the tables alreday defined here # #Check if self.ModeledHdfTopFileVariable!=None: #debug ''' self.debug( [ 'Looking for names of tables here', ('self.',self,['HdfGroupPathStr']) ] ) ''' #Definition Modeled attributes self.ModeledHdfGroupVariable=self.ModeledHdfTopFileVariable.getNode( self.ModelDeriveControllerVariable.HdfGroupPathStr ) #debug ''' self.debug( [ ('looking for tables with the same suffix Str as : '), ('self.',self,['ModeledHdfSuffixStr']) ] ) ''' #Get and sort self.ModeledHdfKeyStrsList=sorted( filter( lambda __KeyStr: __KeyStr.endswith(self.ModeledHdfSuffixStr), self.ModeledHdfGroupVariable._v_leaves.keys() ) ) self.ModeledHdfTablesOrderedDict.update( map( lambda __ModeledKeyStr: ( __ModeledKeyStr, self.ModeledHdfGroupVariable._f_getChild( __ModeledKeyStr ) ), self.ModeledHdfKeyStrsList ) ) #debug ''' self.debug(("self.",self,[ 'ModeledHdfSuffixStr', 'ModeledHdfKeyStrsList' ])) ''' #/################/# # Refind all the names of the tables # #debug ''' self.debug( ('self.',self,[ 'ModeledHdfKeyStrsList', 'ModeledHdfSuffixStr', 'ModeledHdfKeyStr' ]) ) ''' #Get the suffix Strs of all the tables and their index ModeledHdfList=SYS.unzip(map( lambda __StrsList: ( __StrsList[1], ModelingOrderStr.join(__StrsList[2:]) ), map( lambda __ModeledHdfKeyStr: __ModeledHdfKeyStr.split(ModelingOrderStr), self.ModeledHdfKeyStrsList ) ),[0,1] ) #debug self.debug(('vars ',vars(),['ModeledHdfList'])) #/##################/# # Find if there are already some tables here and deduce the index of the table # #Unpack if it is possible if len(ModeledHdfList)>0: #Unpack [ModeledHdfIndexIntsTuple,ModeledHdfSuffixStrsList]=ModeledHdfList #debug ''' self.debug( [ 'There are already some tables', 'ModeledHdfSuffixStrsList is '+str(ModeledHdfSuffixStrsList), "self.ModeledHdfSuffixStr is "+str( self.ModeledHdfSuffixStr) ] ) ''' if self.ModeledHdfSuffixStr not in ModeledHdfSuffixStrsList: #Increment the IndexStr ModeledHdfIndexInt=max(map(int,ModeledHdfIndexIntsTuple))+1 #Strify ModeledHdfIndexStr=str(ModeledHdfIndexInt) #debug ''' self.debug('IndexStr of this new table is '+str(IndexStr)) ''' else: #Get the already setted one ModeledHdfIndexStr=self.ModeledHdfKeyStrsList[ ModeledHdfSuffixStrsList.index(self.ModeledHdfSuffixStr) ].split(ModelingOrderStr)[1] #Intify ModeledHdfIndexInt=(int)(ModeledHdfIndexStr) #debug ''' self.debug('IndexStr of this not new table is '+str(IndexStr)) ''' else: #debug ''' self.debug('There are no tables here') ''' #set to empty lists [ModeledHdfIndexIntsTuple,ModeledHdfSuffixStrsList]=[[],[]] #Init the list ModeledHdfIndexInt=0 #Strify ModeledHdfIndexStr="0" #/##################/# # set the table key str # #debug self.debug( [ 'We set the table key str', ('self.',self,['ModeledHdfKeyStr']) ] ) #Bind with ModeledHdfKeyStr setting self.ModeledHdfKeyStr=ModelingOrderStr+ModeledHdfIndexStr+ModelingOrderStr+self.ModeledHdfSuffixStr #set the ModeledInt self.ModeledHdfIndexInt=ModeledHdfIndexInt #debug ''' self.debug("self.ModeledHdfKeyStr is "+str(self.ModeledHdfKeyStr)) ''' #debug ''' self.debug( [ 'Here we create the table or get it depending if it is new or not', ('self.',self,[ 'ModeledHdfKeyStr', 'ModeledHdfTopFileVariable' ]) ] ) ''' #Check if self.ModeledHdfKeyStr!="" and self.ModeledHdfTopFileVariable!=None: #debug ''' self.debug( [ ('self.',self,[ 'ModeledHdfKeyStr', 'ModeledHdfKeyStrsList' ]) ] ) ''' #Create the Table if not already if self.ModeledHdfKeyStr not in self.ModeledHdfKeyStrsList: #debug ''' self.debug( [ 'The table not exists', ] ) ''' #Create the Table in the hdf5 self.ModeledHdfTable=self.ModeledHdfTopFileVariable.create_table( self.ModeledHdfGroupVariable, self.ModeledHdfKeyStr, self.ModeledDescriptionClass, self.ModeledDescriptionClass.__doc__ if self.ModeledDescriptionClass.__doc__!=None else "This is the "+self.ModeledDescriptionClass.__name__ ) #Append self.ModeledHdfKeyStrsList.append( self.ModeledHdfKeyStr ) else: #debug ''' self.debug( [ 'The table exists', "self.ModeledGroupVariable is "+str(self.ModeledGroupVariable) ] ) ''' #Else just get it self.ModeledHdfTable=self.ModeledHdfGroupVariable._f_getChild( self.ModeledHdfKeyStr ) #set the in the TablesOrderedDict self.ModeledHdfTablesOrderedDict[ self.ModeledHdfKeyStr ]=self.ModeledHdfTable #debug ''' self.debug("self.ModeledHdfTablesOrderedDict is "+str( self.ModeledHdfTablesOrderedDict)) ''' #debug '''
def argument(self,_Variable): #debug ''' self.debug(('locals ',locals(),['_Variable'])) ''' #set if self.ArgumentingFunction==None or _Variable!=None: self.ArgumentingFunction=_Variable #set the ArgumentingDoStr if not already if self.ArgumentingDoStr=="": #debug ''' self.debug(('self.',self,['ArgumentingFunction'])) ''' #Keep only the last part of the name to avoid the FunctingDecorationStrs ArgumentedSplitFunctionStr=self.ArgumentingFunction.__name__.split( Functer.FunctingDecorationStr)[-1] #set self.ArgumentingDoStr=ArgumentedSplitFunctionStr[0].upper( )+ArgumentedSplitFunctionStr[1:] self.ArgumentingDoerStr=Doer.getDoerStrWithDoStr(self.ArgumentingDoStr) #debug ''' self.debug(('self.',self,['ArgumentingDoStr'])) ''' #set the ArgumentedDoingStr self.ArgumentedDoingStr=Doer.getDoingStrWithDoneStr( Doer.getDoneStrWithDoStr(self.ArgumentingDoStr) ) #Find the Arguments Types self.ArgumentedInspectOrderedDict=SYS.getArgumentDictWithFunction( self.ArgumentingFunction) #Definition ArgumentedExecStr='def ArgumentedFunction(' ArgumentedExecStr+=','.join( map( lambda __KeyStr: __KeyStr+"=None", getattr( SYS, SYS.getClassStrWithNameStr( self.ArgumentingDoerStr ) ).DoingAttributeVariablesOrderedDict.keys() ) ) ArgumentedExecStr+=',**_KwargVariablesDict):\n' ArgumentedExecStr+=''' #set in the instance the corresponding listed arguments if they are not None map( lambda __KeyStr,__Variable: _InstanceVariable.__setattr__(__KeyStr,__Variable) if __Variable!=None, map( lambda __InputKeyStr: self.ArgumentedDoingStr+ArgumentingStr.join( __InputKeyStr.split(ArgumentingStr)[1:] ), self.__class__.DoingAttributeVariablesOrderedDict.keys() #self.ArgumentedInspectOrderedDict[ #'InputKeyStrsList'][1:] ), _LiargVariablesList ) #Definition the ArgumentedSetTuplesList ArgumentedKwargTuplesList=map( lambda __ItemTuple: ( self.ArgumentedDoingStr+ArgumentingStr.join( __ItemTuple[0].split(ArgumentingStr)[1:]), __ItemTuple[1] ) if __ItemTuple[0].startswith(ArgumentingStr) else __ItemTuple, _KwargVariablesDict.items() ) #set in the instance the corresponding kwarged arguments map( lambda __ItemTuple: #set direct explicit attributes _InstanceVariable.__setattr__(*__ItemTuple) if hasattr(_InstanceVariable,__ItemTuple[0]) else None, ArgumentedKwargTuplesList ) #Call the argumenting self.ArgumentingFunction return self.ArgumentingFunction(_InstanceVariable,*_LiargVariablesList,**_KwargVariablesDict) ''' #debug print('ArgumentedExecStr is ',ArgumentedExecStr) print('') #Definition the ArgumentedFunction def ArgumentedFunction(_InstanceVariable,*_LiargVariablesList,**_KwargVariablesDict): #debug ''' self.debug( [ ('',locals(),[ '_LiargVariablesList' ]), ('self.',self,[ 'ArgumentingDoStr', 'ArgumentedDoingStr', 'ArgumentedInspectOrderedDict' ]) ] ) ''' #set in the instance the corresponding listed arguments if they are not None map( lambda __KeyStr,__Variable: _InstanceVariable.__setattr__(__KeyStr,__Variable) if __Variable!=None and hasattr(_InstanceVariable,__KeyStr) else None, map( lambda __InputKeyStr: self.ArgumentedDoingStr+ArgumentingStr.join( __InputKeyStr.split(ArgumentingStr)[1:] ), #self.__class__.DoingAttributeVariablesOrderedDict.keys() self.ArgumentedInspectOrderedDict[ 'InputKeyStrsList'][1:] ), _LiargVariablesList ) #Definition the ArgumentedSetTuplesList ArgumentedKwargTuplesList=map( lambda __ItemTuple: ( self.ArgumentedDoingStr+ArgumentingStr.join( __ItemTuple[0].split(ArgumentingStr)[1:]), __ItemTuple[1] ) if __ItemTuple[0].startswith(ArgumentingStr) else __ItemTuple, _KwargVariablesDict.items() ) #set in the instance the corresponding kwarged arguments map( lambda __ItemTuple: #set direct explicit attributes _InstanceVariable.__setattr__(*__ItemTuple) if hasattr(_InstanceVariable,__ItemTuple[0]) else None, ArgumentedKwargTuplesList ) #Call the argumenting self.ArgumentingFunction return self.ArgumentingFunction(_InstanceVariable,*_LiargVariablesList,**_KwargVariablesDict) #set self.ArgumentedFunction=ArgumentedFunction #Return self return self
def do_map(self): #Debug ''' print('l 174 Mapper') print('self.MappingDoMethodStr is ',self.MappingDoMethodStr) print('') ''' #Check if self.MappingDoMethodStr!="": #observe self.observe(True,self.MappingDoMethodStr) #set self.MappedWrapMethodStr=MappingWrapPrefixStr+self.MappingDoMethodStr #Debug ''' print('l 75 Mapper ') print('self.MappedWrapMethodStr is ',self.MappedWrapMethodStr) print('') ''' #Define MappedDoStr=self.MappingDoMethodStr[0].upper()+self.MappingDoMethodStr[1:] MappedDoerStr=Doer.DoStrToDoerStrOrderedDict[MappedDoStr] #Debug ''' print('l 84 Mapper ') print('MappedDoStr is ',MappedDoStr) print('MappedDoerStr is ',MappedDoerStr) print('MappedBaseModule is ',MappedBaseModule) print('') ''' #Definitions MappedBaseClass=getattr( SYS, SYS.getClassStrWithNameStr(MappedDoerStr) ) #get MappedDoExecStr=getattr( MappedBaseClass, 'Do'+MappedBaseClass.NameStr+'ExecStr' ) #debug ''' print('l 206 Mapper') print('MappedDoExecStr is ') print(MappedDoExecStr) print('') ''' #replace MappedDecorationMethodStr=MappingDecorationPrefixStr+MappingDecorationTagStr+MappingDecorationSuffixStr MappedDecorationMethodStr+=self.ObservedWrapMethodStr #Debug ''' print('l 232 Mapper') print('MappedDecorationMethodStr is '+MappedDecorationMethodStr) print('') ''' #replace MappedExecStr='def '+MappedDecorationMethodStr+'('+'('.join( MappedDoExecStr.split('(')[1:] ) #Debug ''' print('l 208 Mapper') print('MappedExecStr is ') print(MappedExecStr) print('') ''' #Add to the ImitatedDoneExecStr MappedExecStr+='\n\treturn map(_InstanceVariable,*_LiargVariablesList,' MappedExecStr+='**dict({\'MapMethodStr\':\''+self.MappedWrapMethodStr+'\',' MappedExecStr+='\'MapClassStr\':\''+self.DoClass.__name__+'\',' MappedExecStr+='\'BaseClassStr\':\''+MappedBaseClass.__name__+'\'' MappedExecStr+='},**_KwargVariablesDict))' #Debug ''' print('l 223 Mapper') print('MappedExecStr is ') print(MappedExecStr) print('') ''' #exec six.exec_(MappedExecStr) #set self.MappedDecorationUnboundMethod=locals()[MappedDecorationMethodStr] #set in the __class__ setattr( self.DoClass, MappedDecorationMethodStr, self.MappedDecorationUnboundMethod ) #make the amalgam setattr( self.DoClass, self.MappingDoMethodStr, self.MappedDecorationUnboundMethod )
def do_database(self): """ """ # debug """ self.debug(('self.',self,['DatabasingSealTuplesList'])) """ # model first self.model() # set a name if it was not already if self.DatabasedKeyStr == "": # debug """ self.debug(('self.',self,['DatabasingKeyStr','ModeledSuffixStr'])) """ # Link set self.DatabasedKeyStr = self.ModeledSuffixStr # Check if len(self.DatabasingSealTuplesList) > 0: self.DatabasingHdfBool = True self.DatabasingMongoBool = False else: self.DatabasingHdfBool = False self.DatabasingMongoBool = True # Check if self.DatabasingHdfBool: # import import tables # Definition the ModelClass class ModelClass(tables.IsDescription): # Add (just like a unique KEY in mysql...) RowInt = tables.Int64Col() # debug """ self.debug(('self.',self,['DatabasedGetStrToColumnStrOrderedDict'])) """ # set the cols in the ModelClass map( lambda __DatabasingColumnTuple: ModelClass.columns.__setitem__( __DatabasingColumnTuple[1], __DatabasingColumnTuple[2] ), self.DatabasingSealTuplesList, ) # Give a name ModelClass.__name__ = SYS.getClassStrWithNameStr(self.DatabasedKeyStr) # set the ModelClass if self.DatabasedModelClassesOrderedDict == None: self.DatabasedModelClassesOrderedDict = collections.OrderedDict() self.DatabasedModelClassesOrderedDict[self.DatabasedKeyStr] = ModelClass # set the DatabasedModelClass self.DatabasedModelClass = ModelClass
def do_mimic(self): #set self.MimickedMethodStr=MimickingPrefixStr+self.MimickingDoMethodStr #Debug ''' print('l 75 Mimicker ') print('self.MimickedMethodStr is ',self.MimickedMethodStr) print('') ''' #Define MimickedDoStr=self.MimickingDoMethodStr[0].upper()+self.MimickingDoMethodStr[1:] MimickedDoerStr=Doer.DoStrToDoerStrOrderedDict[MimickedDoStr] #Debug ''' print('l 84 Mimicker ') print('MimickedDoStr is ',MimickedDoStr) print('MimickedDoerStr is ',MimickedDoerStr) print('') ''' #Definitions MimickedModule=getattr(SYS,MimickedDoerStr) MimickedClass=getattr(MimickedModule,SYS.getClassStrWithNameStr(MimickedDoerStr)) MimickedDoneExecStr=getattr( MimickedClass, MimickedClass.NameStr+'DoneExecStr' ).replace('def DoerFunction','def MimickerFunction') #Debug ''' print('l 99 Mimicker') print('MimickedDoneExecStr is ') print(MimickedDoneExecStr) print('') ''' #Define def MimickedNewFunction(_InstanceVariable,*_LiargVariablesList,**_KwargVariablesDict): #Set MimicMethodStr=_KwargVariablesDict['MimicMethodStr'] del _KwargVariablesDict['MimicMethodStr'] MimicDoStr=MimickingPrefixStr.join(MimicMethodStr.split(MimickingPrefixStr)[1:]) MimicDoStr=MimicDoStr[0].upper()+MimicDoStr[1:] if MimicDoStr[0]!='_' else MimicDoStr[1].upper()+MimicDoStr[2:] MimicNameStr=Doer.DoStrToDoerStrOrderedDict[MimicDoStr] MimicClass=getattr(SYS,SYS.getClassStrWithNameStr(MimicNameStr)) DoClassStr=_KwargVariablesDict['DoClassStr'] del _KwargVariablesDict['DoClassStr'] DoClass=getattr(SYS,DoClassStr) #Debug ''' print('Mimicker l.119 inside of the function MimickedNewFunction') #print('_InstanceVariable is ',_InstanceVariable) print('_LiargVariablesList is ',_LiargVariablesList) print('_KwargVariablesDict is ',_KwargVariablesDict) print('MimicMethodStr is ',MimicMethodStr) print('') ''' if len(_KwargVariablesDict)>0: #group by [ MimicItemTuplesList, MimicNotItemTuplesList ]=SYS.groupby( lambda __ItemTuple: hasattr(_InstanceVariable,__ItemTuple[0]), _KwargVariablesDict.items() ) #Debug ''' print('MimicItemTuplesList is ',MimicItemTuplesList) print('MimicNotItemTuplesList is ',MimicNotItemTuplesList) print('') ''' #set in the instance the corresponding kwarged arguments map( lambda __ItemTuple: #set direct explicit attributes _InstanceVariable.__setattr__(*__ItemTuple), MimicItemTuplesList ) #Define MimicKwargDict=dict(MimicNotItemTuplesList) else: #Define MimicKwargDict={} #Init MimicOutputVariable=None #Debug ''' print('Mimicker l.167 inside of the function MimickedNewFunction') print('DoClass is ',DoClass) print('MimicMethodStr is ',MimicMethodStr) print('') ''' #Get the method MimicUnBoundMethod=getattr( DoClass, MimicMethodStr ) #Debug ''' print('Mimicker l.181 inside of the function MimickedNewFunction') print('MimicUnBoundMethod is ',MimicUnBoundMethod) print('MimicKwargDict is ',MimicKwargDict) print('') ''' #call the Mimicked function if len(MimicKwargDict)>0: MimicOutputVariable=MimicUnBoundMethod( _InstanceVariable, *_LiargVariablesList, **MimicKwargDict ) else: MimicOutputVariable=MimicUnBoundMethod( _InstanceVariable, *_LiargVariablesList ) #Debug ''' print('Mimicker l.178 inside of the function MimickedNewFunction') print('MimicClass is ',MimicClass) print('MimicClass.DoingGetBool is ',MimicClass.DoingGetBool) print('MimicOutputVariable is ',MimicOutputVariable) print('') ''' #Check if MimicClass.DoingGetBool==False: #Return return _InstanceVariable else: #Return the return MimicOutputVariable #Rename MimickedNewFunction.__name__='mimic'+MimickedDoStr+'With'+self.DoClass.NameStr #Debug ''' print('l.225 Mimicker') print('MimickedNewFunction is ',MimickedNewFunction) print('MimickedNewFunction.__name__ is ',MimickedNewFunction.__name__) print('') ''' #Set in the class setattr( self.DoClass, MimickedNewFunction.__name__, MimickedNewFunction ) #Add to the ImitatedDoneExecStr MimickedDoneExecStr+='\n\treturn _InstanceVariable.'+MimickedNewFunction.__name__+'(*_LiargVariablesList,**dict({\'MimicMethodStr\':\''+self.MimickedMethodStr+'\',\'DoClassStr\':\''+self.DoClass.__name__+'\'},**_KwargVariablesDict))' #Debug ''' print('MimickedDoneExecStr is ') print(MimickedDoneExecStr) print('') ''' #exec six.exec_(MimickedDoneExecStr) #set the name locals()[ 'MimickerFunction' ].__name__=self.__class__.NameStr+Doer.DoingDecorationStr+MimickingDecoratioStr+self.MimickingDoMethodStr #set in the __class__ setattr( self.DoClass, self.MimickingDoMethodStr, locals()['MimickerFunction'] )
def MimickedNewFunction(_InstanceVariable,*_LiargVariablesList,**_KwargVariablesDict): #Set MimicMethodStr=_KwargVariablesDict['MimicMethodStr'] del _KwargVariablesDict['MimicMethodStr'] MimicDoStr=MimickingPrefixStr.join(MimicMethodStr.split(MimickingPrefixStr)[1:]) MimicDoStr=MimicDoStr[0].upper()+MimicDoStr[1:] if MimicDoStr[0]!='_' else MimicDoStr[1].upper()+MimicDoStr[2:] MimicNameStr=Doer.DoStrToDoerStrOrderedDict[MimicDoStr] MimicClass=getattr(SYS,SYS.getClassStrWithNameStr(MimicNameStr)) DoClassStr=_KwargVariablesDict['DoClassStr'] del _KwargVariablesDict['DoClassStr'] DoClass=getattr(SYS,DoClassStr) #Debug ''' print('Mimicker l.119 inside of the function MimickedNewFunction') #print('_InstanceVariable is ',_InstanceVariable) print('_LiargVariablesList is ',_LiargVariablesList) print('_KwargVariablesDict is ',_KwargVariablesDict) print('MimicMethodStr is ',MimicMethodStr) print('') ''' if len(_KwargVariablesDict)>0: #group by [ MimicItemTuplesList, MimicNotItemTuplesList ]=SYS.groupby( lambda __ItemTuple: hasattr(_InstanceVariable,__ItemTuple[0]), _KwargVariablesDict.items() ) #Debug ''' print('MimicItemTuplesList is ',MimicItemTuplesList) print('MimicNotItemTuplesList is ',MimicNotItemTuplesList) print('') ''' #set in the instance the corresponding kwarged arguments map( lambda __ItemTuple: #set direct explicit attributes _InstanceVariable.__setattr__(*__ItemTuple), MimicItemTuplesList ) #Define MimicKwargDict=dict(MimicNotItemTuplesList) else: #Define MimicKwargDict={} #Init MimicOutputVariable=None #Debug ''' print('Mimicker l.167 inside of the function MimickedNewFunction') print('DoClass is ',DoClass) print('MimicMethodStr is ',MimicMethodStr) print('') ''' #Get the method MimicUnBoundMethod=getattr( DoClass, MimicMethodStr ) #Debug ''' print('Mimicker l.181 inside of the function MimickedNewFunction') print('MimicUnBoundMethod is ',MimicUnBoundMethod) print('MimicKwargDict is ',MimicKwargDict) print('') ''' #call the Mimicked function if len(MimicKwargDict)>0: MimicOutputVariable=MimicUnBoundMethod( _InstanceVariable, *_LiargVariablesList, **MimicKwargDict ) else: MimicOutputVariable=MimicUnBoundMethod( _InstanceVariable, *_LiargVariablesList ) #Debug ''' print('Mimicker l.178 inside of the function MimickedNewFunction') print('MimicClass is ',MimicClass) print('MimicClass.DoingGetBool is ',MimicClass.DoingGetBool) print('MimicOutputVariable is ',MimicOutputVariable) print('') ''' #Check if MimicClass.DoingGetBool==False: #Return return _InstanceVariable else: #Return the return MimicOutputVariable
def do_call(self): #Module first to know where we are self.package() #debug ''' print("self.CallingVariable is ",self.CallingVariable) print('') ''' #If it was not yet setted or changed if self.CallingVariable==None or self.CallingVariable.__name__!=self.CallingFunctionStr: #debug ''' print('Get in the module') print('self.PackagingModuleVariable is '+str(self.PackagingModuleVariable)) print('') ''' #Get maybe the one in the module if self.CallingFunctionStr!="": #debug ''' print('Get in the module with the function Str') print('self.CallingFunctionStr is ',self.CallingFunctionStr) print('') ''' #Get and return self.CallingVariable=getattr(self.PackagedModuleVariable,self.CallingFunctionStr) return self #Get the function if self.CallingVariable==None or self.CallingVariable.__name__!=self.CallingMethodStr: #debug ''' print('Get in a class') print('self.PackagingModuleVariable is '+str(self.PackagingModuleVariable)) print('self.CallingVariable is ',self.CallingVariable) print('self.CallingMethodStr is ',self.CallingMethodStr) print('self.CallingClass is ',self.CallingClass) print('self.CallingClassStr is ',self.CallingClassStr) print('self.CallingInstanceVariable is ',self.CallingInstanceVariable) print('') ''' #Get with the CallingInstanceVariable class maybe if self.CallingClass==None and self.CallingInstanceVariable!=None: self.CallingClass=self.CallingInstanceVariable.__class__ #Import the module if not already if self.CallingClass==None: if self.CallingClassStr!="": self.CallingClass=getattr(self.PackagedModuleVariable,self.CallingClassStr) else: self.CallingClass=getattr( self.PackagedModuleVariable, SYS.getClassStrWithNameStr( SYS.getNameStrWithModuleStr(self.PackagedModuleVariable.__name__) ) ) #debug ''' print('Now get the unbounded method function') print('self.CallingClass is '+str(self.CallingClass)) print('') ''' #Check if self.CallingMethodStr!="": #debug ''' print('self.CallingMethodStr is ',self.CallingMethodStr) print('') ''' #Return self.CallingVariable=getattr(self.CallingClass,self.CallingMethodStr)