def do_recruit(self): #Check if type(self.VisitingBeforeUpdateList)!=list: self.VisitingBeforeUpdateList=[] #add self.VisitingBeforeUpdateList+=[ ( 'PickingKeyVariablesList',['/'] ), ( 'ConcludingConditionVariable', self.RecruitingConcludeConditionVariable ), ( 'cumulate', SYS.ApplyDictClass() ) ] #visit self.visit() #debug ''' self.debug(('self.',self,['CumulatedVariablesList'])) ''' #flat self.RecruitedFlatCumulateVariablesList=SYS.filterNone( SYS.flat( self.CumulatedVariablesList ) )
def do_transmit(self): # debug """ self.debug(('self.',self,['TransmittingSelfIsBool'])) """ # Check if self.TransmittingSelfIsBool: # update self.update(self.TransmittingUpdateList) # map self.TransmittedVariablesList = SYS.flat( map( lambda __TransmittingCollectionStr: map( lambda __DeriveNoderPointer: __DeriveNoderPointer.CatchToPointVariable, getattr(self, __TransmittingCollectionStr + "CollectionOrderedDict").values(), ) if hasattr(self, __TransmittingCollectionStr + "CollectionOrderedDict") else [], self.TransmittingCollectionStrsList, ) ) # command self.command(self.TransmittingUpdateList, self.TransmittedVariablesList, _GatherIsBool=False)
def do_array(self): #init self.ProducedDeriveNodersList=[self] #map self.ArrayedDeriveNodersListsList=map( lambda __ArrayingCollectionStr,__ArrayingNodeKeyStrsList,__ArrayingCollectionClass,__ArrayingUpdateVariable: self.__setitem__( 'ProducedDeriveNodersList', SYS.flat( map( lambda __ProducedDeriveNoder: __ProducedDeriveNoder.produce( __ArrayingCollectionStr, __ArrayingNodeKeyStrsList, __ArrayingCollectionClass, __ArrayingUpdateVariable ).ProducedDeriveNodersList, self.ProducedDeriveNodersList, ) ) ).ProducedDeriveNodersList, self.ArrayingCollectionStrsList, self.ArrayingNodeKeyStrsListsList, self.ArrayingCollectionClassesList, self.ArrayingUpdateVariablesList )
def do_command(self): """Collect with _GatheringKeyVariablesList and do a all sets for each with _UpdatingItemVariable""" #Check if self.CommandingGatherIsBool: #Get the GatheredVariablesList self.gather() #debug ''' self.debug( ('self.',self,[ 'CommandingUpdateList', 'GatheringVariablesList', 'GatheredVariablesList' ] ) ) ''' #Check if len(self.GatheredVariablesList)>0: #Just keep the values self.CommandingGraspVariablesList=SYS.flat( SYS.unzip( self.GatheredVariablesList,[1] ) ) #debug ''' self.debug(("self.",self,['CommandingGraspVariablesList'])) ''' #Check for the order if self.CommandingOrderStr=="AllSetsForEach": #For each __GatheredVariable it is updating with _UpdatingItemVariable map( lambda __CommandedVariable: __CommandedVariable.update(self.CommandingUpdateList), self.CommandingGraspVariablesList ) elif self.CommandingOrderStr=="EachSetForAll": #For each SettingTuple it is setted in _GatheredVariablesList map( lambda __SettingVariableTuple: map( lambda __CommandedVariable: __CommandedVariable.__setitem__(*__SettingVariableTuple), self.CommandingGraspVariablesList ), self.CommandingUpdateList.items() if hasattr(self.CommandingUpdateList,'items') else self.CommandingUpdateList )
def do_network(self): #recruit first if self.VisitingCollectionStrsList==None: self.VisitingCollectionStrsList=[self.CollectingCollectionStr] #debug ''' self.debug(('self.',self,['VisitingCollectionStrsList'])) ''' #recruit self.recruit() self.NetworkedDeriveConnectersList=self.RecruitedFlatCumulateVariablesList #debug ''' self.debug(('self.',self,['NetworkedDeriveConnectersList'])) ''' #map a connect self.NetworkedDerivePointersList=SYS.flat( map( lambda __NetworkedDeriveConnecter,__IndexInt: __NetworkedDeriveConnecter.parent( ).connect( _ConnectingCatchCollectionStr=self.NetworkingCatchStr+self.NetworkingSuffixStr, _ConnectingAttentionCollectionStr=self.NetworkingAttentionStr+self.NetworkingSuffixStr ).update( [ ('NetworkCollectionStr',self.NetworkingSuffixStr), ('NetworkCatchStr',self.NetworkingCatchStr), ('NetworkAttentionStr',self.NetworkingAttentionStr), ('NetworkIndexInt',__IndexInt), ( 'NetworkKeyStr', __NetworkedDeriveConnecter.ParentedNodePathStr+'/'+__NetworkedDeriveConnecter.NodeKeyStr ), ( 'point', SYS.ApplyDictClass( { 'LiargVariablesList': [ self, 'NetworkPointDeriveNetworker' ] } ) ) ] ).ConnectedCatchDerivePointersList, self.NetworkedDeriveConnectersList, xrange(len(self.NetworkedDeriveConnectersList)) ) )
def getSwitch(_InstanceVariable,_MethodVariable=None): #Check if _MethodVariable==None: SwitchItemTuplesList=_InstanceVariable.SwitchMethodDict.items() elif type(_MethodVariable) in [list,tuple]: SwitchItemTuplesList=map( lambda __MethodStr: ( __MethodStr, _InstanceVariable.SwitchMethodDict[__MethodStr] ), _MethodVariable ) else: SwitchItemTuplesList=[ ( _MethodVariable, _InstanceVariable.SwitchMethodDict[_MethodVariable] ) ] #Debug ''' print('getSwitch l 266') print('_MethodVariable is ') print(_MethodVariable) print('SwitchItemTuplesList is ') print(SwitchItemTuplesList) print('') ''' #return WatchKeyStrsList=SYS.flat( SYS.flat( map( lambda __SwitchItemTuple: map( lambda __ClassStr: map( lambda __HookStr: 'Watch'+__HookStr+SYS.getUpperWordStr( __SwitchItemTuple[0] )+'With'+SYS.getNameStrWithClassStr( __ClassStr )+'Bool', ['Before','After'] ), map(lambda __Class:__Class.__name__,__SwitchItemTuple[1]) ), SwitchItemTuplesList ) ) ) #Debug ''' print('getSwitch l 300') print('WatchKeyStrsList is ') print(WatchKeyStrsList) print('WatchKeyStrsList is ') print(WatchKeyStrsList) print('') ''' #return return dict( zip( WatchKeyStrsList, map( lambda __WatchKeyStr: getattr(_InstanceVariable,__WatchKeyStr), WatchKeyStrsList ) ) )
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_brian(self): #network first self.network( **{ 'RecruitingConcludeConditionVariable':[ ('__class__.__mro__',operator.contains,Populater.PopulaterClass) ] } ) """ #populate map( lambda __NetworkedDeriveConnecter: __NetworkedDeriveConnecter.populate(), self.NetworkedDeriveConnectersList ) """ """ #set the different times self.BrianedStepTimeFloatsList=list( set( SYS.flat( map( lambda __BrianingDerivePopulater: SYS.unzip( __BrianingDerivePopulater.MoniteringStateArgumentVariablesList, [2] ) if len( __BrianingDerivePopulater.MoniteringStateArgumentVariablesList )>0 else [], self.NetworkedDeriveConnectersList ) ) ) ) """ #debug ''' self.debug(('self.',self,['BrianedStepTimeFloatsList'])) ''' #import import brian #Check if self.BrianingTimeDimensionVariable==None: self.BrianingTimeDimensionVariable=brian.ms #init self.BrianedNetworkVariable=brian.MagicNetwork() """ #set the clocks self.BrianedSimulationClock=brian.Clock( dt=self.SimulatingStepTimeFloat*self.BrianingTimeDimensionVariable ) self.BrianedClocksDict=dict( map( lambda __BrianedStepTimeFloat: ( str(__BrianedStepTimeFloat), brian.Clock( dt=__BrianedStepTimeFloat*self.BrianingTimeDimensionVariable ) ), self.BrianedStepTimeFloatsList ) ,**{ str( self.SimulatingStepTimeFloat ):self.BrianedSimulationClock } ) #debug self.debug(('self.',self,['BrianedClocksDict'])) """ #map self.BrianedNeuronGroupsList=map( lambda __BrianingDerivePopulater: __BrianingDerivePopulater.NeuronGroup, self.NetworkedDeriveConnectersList ) ''' # map( lambda __BrianingDerivePopulater: __BrianingDerivePopulater.__setitem__( 'NeuronGroup', brian.NeuronGroup( __BrianingDerivePopulater.PopulatingUnitsInt, __BrianingDerivePopulater.PopulatingEquationStr, clock=self.BrianedClocksDict[str(self.SimulatingStepTimeFloat)] ) ).NeuronGroup, self.NetworkedDeriveConnectersList ) ''' #set the clocks and state monitors """ self.BrianedStateMonitorsList=SYS.flat( map( lambda __BrianingDerivePopulater: map( lambda __MoniteringStateArgumentVariable: __BrianingDerivePopulater.__setitem__( str(__MoniteringStateArgumentVariable)+'StateMonitor', getattr( brian, 'StateMonitor' )( __BrianingDerivePopulater.NeuronGroup, __MoniteringStateArgumentVariable[0], record=__MoniteringStateArgumentVariable[1], clock=self.BrianedClocksDict[str(__MoniteringStateArgumentVariable[2])] ) if hasattr(__MoniteringStateArgumentVariable,'items')==False else map( lambda __MoniteringStateArgumentVariableItemTuple: getattr( brian, 'StateMonitor' )( __BrianingDerivePopulater.NeuronGroup, __MoniteringStateArgumentVariable['StateVariableStr'], ) , __MoniteringStateArgumentVariable.items() ) ).SettingValueVariable, __BrianingDerivePopulater.MoniteringStateArgumentVariablesList ), self.NetworkedDeriveConnectersList ) ) """ #set the spike monitors self.BrianedSpikeMonitorsList=SYS.flat( map( lambda __BrianingDerivePopulater: map( lambda __MoniteringSpikeTuple: __BrianingDerivePopulater.__setitem__( str(__MoniteringSpikeTuple)+'SpikeMonitor', brian.SpikeMonitor( __BrianingDerivePopulater.NeuronGroup, ) ).SettingValueVariable, __BrianingDerivePopulater.MoniteringSpikeTuplesList ), self.NetworkedDeriveConnectersList ) ) """ #debug self.debug(('self.',self,['NetworkedGraphTuplesList'])) """ ''' #set connections self.BrianedConnectionsList=map( lambda __ConnectionTuple: map( lambda __ListedVariable: __ConnectionTuple[0].__setitem__( str( ( __ConnectionTuple[0].NodeKeyStr, __ListedVariable.NodeKeyStr ) )+'Connection', brian.Connection( __ConnectionTuple[0].NeuronGroup, __ListedVariable.NeuronGroup ) ).SettingValueVariable, __ConnectionTuple[1][0] )+map( lambda __ListedVariable: __ListedVariable.__setitem__( str( ( __ListedVariable.NodeKeyStr, __ConnectionTuple[0].NodeKeyStr ) )+'Connection', brian.Connection( __ListedVariable.NeuronGroup, __ConnectionTuple[0].NeuronGroup ) ).SettingValueVariable, __ConnectionTuple[1][1] ), self.NetworkedConnectionTuplesList ) ''' """ #debug ''' self.debug(('self.',self,['BrianedNeuronGroupsList'])) ''' #alias BrianedNetworkVariable=self.BrianedNetworkVariable """ #add map( lambda __BrianedVariable: self.BrianedNetworkVariable.add(__BrianedVariable), self.BrianedNeuronGroupsList+self.BrianedConnectionsList+self.BrianedStateMonitorsList+self.BrianedSpikeMonitorsList ) """
def do_inform(self): #debug self.debug(('self.',self,['DocumentingReadmeIsBool','DocumentingConceptIsBool'])) #install first self.install() #Check if self.DocumentingConceptFolderPathStr=="": self.DocumentingConceptFolderPathStr='ShareYourSystem'.join( os.getcwd().split('ShareYourSystem')[:-1] )+'ShareYourSystem/' #debug ''' self.debug(('self.',self,['DocumentingConceptFolderPathStr'])) ''' """ #direct the Install command self.direct( lambda _LiargVariablesList,_FolderPathStr,_FileKeyStrsList: self.readme( **{ 'FolderingPathVariable':_FolderPathStr } ) if '__init__.py' in _FileKeyStrsList and _FolderPathStr.startswith('_' )==False else None ,[], **{'FolderingPathVariable':self.DocumentingConceptFolderPathStr} ) """ #debug self.folder(self.DocumentingConceptFolderPathStr) #debug ''' self.debug(('self.',self,['FolderedDirKeyStrsList'])) ''' #filter self.DocumentedNameStrsList=SYS._filter( lambda __FolderedDirKeyStr: os.path.isdir( self.FolderingPathVariable+__FolderedDirKeyStr ) and __FolderedDirKeyStr in Doer.DoerStrToDoStrOrderedDict.keys(), self.FolderedDirKeyStrsList ) #debug ''' self.debug(('self.',self,['DocumentedNameStrsList','InstalledNameStrsList'])) ''' #sort self.DocumentedNameStrsList=SYS._filter( lambda __InstalledNameStr: __InstalledNameStr in self.DocumentedNameStrsList, self.InstalledNameStrsList ) #map self.DocumentedModulePathStrsList=map( lambda __DocumentedNameStr: self.FolderingPathVariable+__DocumentedNameStr+'/', self.DocumentedNameStrsList ) #debug ''' self.debug(('self.',self,[ 'DocumentedNameStrsList', 'DocumentedModulePathStrsList' ])) ''' #Check self.DocumentedConceptStr=self.FolderingPathVariable.split('/')[-1] if self.FolderingPathVariable[-1]!='/' else self.FolderingPathVariable.split('/')[-2] if self.DocumentedConceptStr in PluralStrToSingularStrOrderedDict.keys(): self.DocumentedConceptModule=self.package(self.FolderedModuleStr).PackagingModuleVariable #debug ''' self.debug(('self.',self,['DocumentedConceptModule'])) ''' #filter self.DocumentedModulesList=SYS._filter( lambda __AttributeValueVariable: type(__AttributeValueVariable).__name__=='module', self.DocumentedConceptModule.__dict__.values() ) #debug ''' self.debug(('self.',self,['DocumentedModulesList'])) ''' #map self.DocumentedPresentationsDictsList=map( lambda __DocumentedModulePathStr: self.readme( **{ 'FolderingPathVariable':__DocumentedModulePathStr } ).load( **{ 'FilingKeyStr':'Presentation.ipynb', 'LoadingFormatStr':'json' } ).close().LoadedReadVariable if self.DocumentingReadmeIsBool else self.load( **{ 'FolderingPathVariable':__DocumentedModulePathStr, 'FilingKeyStr':'Presentation.ipynb', 'LoadingFormatStr':'json' } ).close().LoadedReadVariable, self.DocumentedModulePathStrsList ) #debug ''' self.debug( 'self.DocumentedPresentationsDictsList is '+SYS._str(self.DocumentedPresentationsDictsList) ) ''' #Check if self.DocumentingConceptIsBool: #Copy self.DocumentedConceptNotebookDict=copy.copy(Celler.CellingInitDict) #SYS._print(self.DocumentedPresentationsDictsList[0]['worksheets'][0]['cells'][0]) #print(self.DocumentedConceptNotebookDict) DocumentedFlatPresentationsDictsList=SYS.flat( map( lambda __DocumentedPresentationsDict: copy.deepcopy( __DocumentedPresentationsDict['worksheets'][0]['cells'] ), self.DocumentedPresentationsDictsList ) ) #Flat all the presentations self.DocumentedConceptNotebookDict['worksheets']=[ { 'cells':map( lambda __DocumentedFlatPresentationsDict,__IndexInt: dict(__DocumentedFlatPresentationsDict,**{'prompt_number':__IndexInt}), DocumentedFlatPresentationsDictsList, xrange(len(DocumentedFlatPresentationsDictsList)) ) } ] #debug self.debug(('self.',self,['DocumentedConceptNotebookDict'])) #Write self.write( self.DocumentedConceptNotebookDict, **{ 'FolderingPathVariable':self.DocumentingConceptFolderPathStr, 'FilingKeyStr':'Concept'+self.GuidingBookStr+'.ipynb', 'LoadingFormatStr':'json' } ).close() #nbconvert self.NotebookedCodeDict=self.DocumentedConceptNotebookDict self.nbconvert( _FormatStr='Slide', **{ 'FolderingPathVariable':self.DocumentingConceptFolderPathStr, 'NotebookingFileKeyStr':'Concept'+self.GuidingBookStr+'.ipynb' } ) #Check if self.NbconvertingFormatStr=='Slide': #change the reveal.js directory self.load(**{ 'FilingKeyStr':self.FilingKeyStr.replace('.ipynb','.slides.html'), 'LoadingFormatStr':'txt' }) self.LoadedReadVariable=self.LoadedReadVariable.replace('reveal.js/','') self.write(self.LoadedReadVariable) #mv os.popen('mv '+self.FiledPathStr.replace('.ipynb','.slides.html')+' '+DocumentingOntologyFolderPathStr+self.__class__.NameStr+self.GuidingBookStr+'.html')
def do_command(self): """ """ #/####################/# # Adapt the type for getting things to command # #debug ''' self.debug( [ 'Adapt the type for getting things to command', ("self.",self,[ 'CommandingGetVariable', 'CommandingSetVariable' ]) ] ) ''' #Check if type(self.CommandingGetVariable)!=list: #debug ''' self.debug( [ 'We get nicely', ('self.',self,['CommandingGetVariable']) ] ) ''' #get CommandedValueVariablesList=self[ self.CommandingGetVariable ] #Check if type(CommandedValueVariablesList)!=list: CommandedValueVariablesList=[CommandedValueVariablesList] else: #map a get CommandedValueVariablesList=map( lambda __CommandingGetVariable: self[__CommandingGetVariable], self.CommandingGetVariable ) #flat maybe CommandedValueVariablesList=SYS.flat(CommandedValueVariablesList) #filter CommandedValueVariablesList=SYS.filterNone(CommandedValueVariablesList) #debug ''' self.debug( [ 'in the end, CommandedValueVariablesList is ', SYS._str(CommandedValueVariablesList) ] ) ''' #/###################/# # Check if we have to walk before # #Check if self.CommandingBeforeWalkRigidBool: #debug ''' self.debug( [ 'we are going to walk before the command', 'CommandedValueVariablesList is '+SYS._str(CommandedValueVariablesList), 'self.getDoing(SYS.CommanderClass).values() is '+SYS._str (self.getDoing( SYS.CommanderClass).values()) ] ) ''' #Debug ''' for __CommandedValueVariable in CommandedValueVariablesList: #debug self.debug( '__CommandedValueVariable is '+SYS._str( __CommandedValueVariable) ) #set __CommandedValueVariable.set( 'GettingNewBool',False ).command( *self.getDoing().values() ).set( 'GettingNewBool',True ) ''' #set CommandedOrderedDict=self.getDoing( SYS.CommanderClass ) CommandedOrderedDict['CommandingBeforeSelfRigidBool']=False CommandedLiargVariablesList=CommandedOrderedDict.values() #map the recursion but pay watch to not set new things to walk in...it is an infinite walk either ! map( lambda __CommandedValueVariable: __CommandedValueVariable.set( 'GettingNewBool',False ).command( *CommandedLiargVariablesList ).set( 'GettingNewBool',True ), CommandedValueVariablesList ) #/####################/# # Adapt the type for setting things in the commanded variables # #debug ''' self.debug( [ 'Adapt the type for setting things in the commanded variables', ("self.",self,['CommandingSetVariable']) ] ) ''' #Check if type(self.CommandingSetVariable)!=list: #Check if hasattr(self.CommandingSetVariable,'items'): #items CommandedSetVariablesList=self.CommandingSetVariable.items() elif type(self.CommandingSetVariable )==str and self.CommandingSetVariable.startswith( Getter.GetCallPrefixStr ): #list CommandedSetVariablesList=[ ('get',self.CommandingSetVariable) ] else: #list CommandedSetVariablesList=[ self.CommandingSetVariable ] else: #alias CommandedSetVariablesList=self.CommandingSetVariable #debug ''' self.debug( [ 'in the end, CommandedSetVariablesList is ', SYS._str(CommandedSetVariablesList) ] ) ''' #/###################/# # Ok now we command locally # #Check if self.CommandingBeforeSelfRigidBool: #debug ''' self.debug( 'We command before self here' ) ''' #add self[Setter.SetMapStr](CommandedSetVariablesList) #Check for the order if self.CommandingOrderStr=="AllSetsForEachGet": #map map( lambda __CommandedValueVariable: map( lambda __CommandedSetVariable: __CommandedValueVariable.set( *__CommandedSetVariable ), CommandedSetVariablesList ), CommandedValueVariablesList ) elif self.CommandingOrderStr=="EachSetForAllGets": #map map( lambda __CommandedSetVariable: map( lambda __CommandedValueVariables: __CommandedValueVariables.set( *__CommandedSetVariable ), CommandedValueVariablesList ), CommandedSetVariablesList ) #Check if self.CommandingAfterSelfRigidBool: #debug ''' self.debug( 'We command after self here' ) ''' #add self[Setter.SetMapStr](CommandedSetVariablesList) #/###################/# # And we check for a walk after # #Check if self.CommandingAfterWalkRigidBool: #debug ''' self.debug( [ 'we are going to walk the command', 'CommandedValueVariablesList is '+SYS._str(CommandedValueVariablesList) ] ) ''' #Debug ''' for __CommandedValueVariable in CommandedValueVariablesList: #debug self.debug( '__CommandedValueVariable is '+SYS._str( __CommandedValueVariable) ) #set __CommandedValueVariable.set( 'GettingNewBool',False ).command( *self.getDoing().values() ).set( 'GettingNewBool',True ) ''' #set CommandedOrderedDict=self.getDoing( SYS.CommanderClass ) CommandedOrderedDict['CommandingBeforeSelfRigidBool']=False CommandedLiargVariablesList=CommandedOrderedDict.values() #map the recursion but pay watch to not set new things to walk in...it is an infinite walk either ! map( lambda __CommandedValueVariable: __CommandedValueVariable.set( 'GettingNewBool',False ).command( *CommandedLiargVariablesList ).set( 'GettingNewBool',True ), CommandedValueVariablesList )
plt.subplot(141) plt.plot( SampleFloatsArray, MyNumscipyer.NumscipiedValueFloatsArray.T ) plt.subplot(142) plt.plot( MyNumscipyer.NumscipiedFourierFrequencyFloatsArray, MyNumscipyer.NumscipiedFourierAmplitudeFloatsArray.T ) map( lambda __NumscipiedFourierMaxTupleFloat: plt.plot( *__NumscipiedFourierMaxTupleFloat, marker='o' ), SYS.flat(MyNumscipyer.NumscipiedFourierMaxTupleFloatsArray) ) plt.subplot(143) plt.plot( MyNumscipyer.NumscipiedFourierFrequencyFloatsArray, MyNumscipyer.NumscipiedFourierPhaseFloatsArray.T ) plt.subplot(144) plt.plot( MyNumscipyer.NumscipiedFourierFrequencyFloatsArray, SYS.sum(MyNumscipyer.NumscipiedFourierCrossPhaseFloatsArray).T ) plt.show()
{ "HintVariable": "/NodePointDeriveNoder/<Connecters>" + __PrefixStr + "Connecter", "SynapsingKwargVariablesDict": {"pre": "gi-=9*mV"}, } ), ["E", "I"], ), }, ], ) # ConnectedCatchDerivePointersList = SYS.flat( map( lambda __Connecter: __Connecter.connect( _CatchCollectionStr="PostConnecters", _AttentionCollectionStr="PreConnecters" ).ConnectedCatchDerivePointersList, MyProducer["<Connecters>"], ) ) SYS._print(map(lambda __Pointer: __Pointer["SynapsingKwargVariablesDict"], ConnectedCatchDerivePointersList)) # Print SYS._print( [ 'MyProducer["<Connecters>EConnecter"].PostConnectersCollectionOrderedDict.keys() is', MyProducer["<Connecters>EConnecter"].PostConnectersCollectionOrderedDict.keys(), ] )
def do_document(self): #debug ''' self.debug( [ ('self.',self,[ 'DocumentingSubReadmeIsBool', 'DocumentingConceptDocumentIsBool' ]) ] ) ''' #Check if self.DocumentingConceptFolderPathStr=="": self.DocumentingConceptFolderPathStr='ShareYourSystem'.join( os.getcwd().split('ShareYourSystem')[:-1] )+'ShareYourSystem/' #debug ''' self.debug(('self.',self,['DocumentingConceptFolderPathStr'])) ''' #debug self.folder( self.DocumentingConceptFolderPathStr ) self.DocumentedConceptModuleStr=self.FolderedModuleStr #debug ''' self.debug(('self.',self,[ 'FolderedModuleStr', 'FolderedDirKeyStrsList' ])) ''' #filter self.DocumentedSubNameStrsList=SYS._filter( lambda __FolderedDirKeyStr: os.path.isdir( self.FolderingPathVariable+__FolderedDirKeyStr ) and __FolderedDirKeyStr in Doer.DoerStrToDoStrOrderedDict.keys(), self.FolderedDirKeyStrsList ) #debug ''' self.debug(('self.',self,['DocumentedSubNameStrsList','DocumentNameStrsList'])) ''' #sort self.DocumentedSubNameStrsList=SYS._filter( lambda __DocumentNameStr: __DocumentNameStr in self.DocumentedSubNameStrsList, DocumentNameStrsList ) #map self.DocumentedSubModuleStrsList=map( lambda __DocumentedSubNameStr: self.DocumentedConceptModuleStr+'.'+__DocumentedSubNameStr, self.DocumentedSubNameStrsList ) #Check self.DocumentedConceptNameStr=self.FolderingPathVariable.split( '/' )[-1] if self.FolderingPathVariable[-1]!='/' else self.FolderingPathVariable.split('/' )[-2] #debug ''' self.debug(('self.',self,[ 'DocumentedSubNameStrsList', 'DocumentedSubModuleStrsList', 'DocumentedConceptNameStr' ])) ''' #check if self.DocumentedConceptNameStr in SYS.PluralStrToSingularStrOrderedDict.keys(): #debug self.debug( [ 'We get the concept module', ('self.',self,[ 'DocumentedConceptNameStr' ]) ] ) #folder self.DocumentedConceptModule=self.folder( getattr(SYS,self.DocumentedConceptNameStr) ).FolderedModuleDict['ModuleVariable'] #join self.DocumentedConceptModuleFolderPathStr='/'.join( self.DocumentedConceptModule.__file__.split( '/' )[:-1] )+'/' #debug ''' self.debug(('self.',self,['DocumentedConceptModule'])) ''' #filter self.DocumentedSubModulesList=SYS._filter( lambda __AttributeValueVariable: type(__AttributeValueVariable).__name__=='module', self.DocumentedConceptModule.__dict__.values() ) #debug ''' self.debug(( 'self.',self,[ 'DocumentedSubModulesList' ] )) ''' #Check if self.DocumentingSubReadmeIsBool: #debug ''' self.debug( [ 'we build sub modules readmes here', ('self.',self,['DocumentedSubModuleStrsList']) ] ) ''' #map map( lambda __DocumentedSubModuleStr: self.folder( __DocumentedSubModuleStr ).scriptbook( _GuideTuplesList=[ ('001','Document','Markdown'), ], **{ 'GuidingBookStr':"Doc", } ).notebook( "PreReadme.ipynb" ).nbconvert( "Readme.md" ), self.DocumentedSubModuleStrsList ) #Check if self.DocumentingConceptSlideIsBool: #debug ''' self.debug( [ 'we slide here', ('self.',self,['DocumentedSubModuleStrsList']) ] ) ''' #map map( lambda __DocumentedSubModuleStr: self.folder( __DocumentedSubModuleStr ).scriptbook( _GuideTuplesList=[ ('001','Document','Markdown'), ('002','Github','Markdown'), ], **{ 'GuidingBookStr':"Doc", } ).notebook( "Presentation.ipynb", **{'WritingLoadBool':False} ).nbconvert( "Presentation.html", 'Slide' ), self.DocumentedSubModuleStrsList ) #mv for Nbviewer ipython notebooks map( lambda __DocumentedSubModuleStr: os.popen( 'cp '+sys.modules[ __DocumentedSubModuleStr ].LocalFolderPathStr+'Presentation.ipynb '+DocumentNbviewerLocalFolderPathStr+__DocumentedSubModuleStr.split( '.' )[-1]+'.ipynb' ), self.DocumentedSubModuleStrsList ) #mv for Ouvaton slide in html map( lambda __DocumentedSubModuleStr: os.popen( 'cp '+sys.modules[ __DocumentedSubModuleStr ].LocalFolderPathStr+'Presentation.html '+DocumentOntologyLocalFolderPathStr+__DocumentedSubModuleStr.split( '.' )[-1]+'.html' ), self.DocumentedSubModuleStrsList ) #mv for Ouvaton slide in php map( lambda __DocumentedSubModuleStr: os.popen( 'cp '+sys.modules[ __DocumentedSubModuleStr ].LocalFolderPathStr+'Presentation.html '+DocumentOntologyLocalFolderPathStr+__DocumentedSubModuleStr.split( '.' )[-1]+'.php' ), self.DocumentedSubModuleStrsList ) #map self.DocumentedSubModuleLocalFolderPathStrsList=map( lambda __DocumentedSubModuleStr: SYS.PythonlogyLocalFolderPathStr+__DocumentedSubModuleStr.replace( '.','/' ), self.DocumentedSubModuleStrsList ) #map self.DocumentedPresentationsDictsList=map( lambda __DocumentedSubModuleFolderPathStr: self.folder( __DocumentedSubModuleFolderPathStr ).file( 'Presentation.ipynb', _ModeStr='r', _FormatStr='json' ).file( _ModeStr='c' ).FiledReadVariable, self.DocumentedSubModuleLocalFolderPathStrsList ) #debug ''' self.debug( 'self.DocumentedPresentationsDictsList is '+SYS._str(self.DocumentedPresentationsDictsList) ) ''' #copy self.DocumentedConceptNotebookDict=copy.copy(Celler.CellInitDict) #flat DocumentedFlatPresentationsDictsList=SYS.flat( map( lambda __DocumentedPresentationsDict: copy.deepcopy( __DocumentedPresentationsDict['worksheets'][0]['cells'] ), self.DocumentedPresentationsDictsList ) ) #Flat all the presentations self.DocumentedConceptNotebookDict['worksheets']=[ { 'cells':map( lambda __DocumentedFlatPresentationsDict,__IndexInt: dict(__DocumentedFlatPresentationsDict,**{ 'prompt_number':__IndexInt}), DocumentedFlatPresentationsDictsList, xrange(len(DocumentedFlatPresentationsDictsList)) ) } ] #debug ''' self.debug(('self.',self,['DocumentedConceptNotebookDict'])) ''' #Write self.folder( self.DocumentingConceptFolderPathStr ).file( _KeyStr='Concept'+self.GuidingBookStr+'.ipynb', _WriteVariable=self.DocumentedConceptNotebookDict, _FormatStr="json" ).file( _ModeStr='c' ) #nbconvert self.NotebookedCodeDict=self.DocumentedConceptNotebookDict self.folder( self.DocumentingConceptFolderPathStr ).nbconvert( _FormatStr='Slide', _FileKeyStr='Concept'+self.GuidingBookStr+'.ipynb' ) #set self.DocumentedSlideLocalFilePathStr=DocumentOntologyLocalFolderPathStr+self.DocumentedConceptModule.__name__.split('.')[-1]+'.html' #cp os.popen('cp '+self.FiledPathStr+' '+self.DocumentedSlideLocalFilePathStr+self.DocumentedConceptModule.__name__.split('.')[-1]+'.ipynb') #mv with .html extension os.popen( 'cp '+self.FiledPathStr.replace( '.ipynb', '.html' )+' '+self.DocumentedSlideLocalFilePathStr ) #mv with .php extension os.popen( 'mv '+self.FiledPathStr.replace( '.ipynb', '.html' )+' '+self.DocumentedSlideLocalFilePathStr.replace('.html','.php') ) #deploy try: self.deploy( _ClientFilePathStrToServerFilePathStrOrderedDict=collections.OrderedDict( [ ( self.DocumentedSlideLocalFilePathStr, DocumentOntologyOuvatonFolderPathStr+self.DocumentedConceptModule.__name__.split('.' )[-1]+'.php' ) ] ) ) except: print('There is NO Internet !') #Check if self.DocumentingConceptReadmeIsBool: #debug ''' self.debug('we build the concept readme here') ''' #import submodules ''' map( lambda __DocumentedSubModuleStr: importlib.import_modules(__DocumentedSubModuleStr), self.DocumentedSubModuleStrsList ) ''' #readme self.folder( self.DocumentedConceptModuleStr ).scriptbook( _GuideTuplesList=[ ('001','Document','Markdown'), ('002','Ouvaton','Markdown'), ('1','Github','Markdown'), ], **{'GuidingBookStr':"Doc"} ) #notebook self.scriptbook( _GuideTuplesList=[] ).notebook( "PreReadme.ipynb" ).nbconvert( "Readme.md", 'Markdown', ) #Check if self.DocumentingConceptDocumentIsBool: #debug ''' self.debug( [ 'we document here', ('self.',self,['DocumentedConceptModuleFolderPathStr']) ] ) ''' ''' #document self.document( **{'PackagingModuleVariable':self.DocumentedConceptModuleStr} ) ''' #folder self.folder(self.DocumentedConceptModuleStr) #mv with .php extension os.popen( 'cp '+self.PackagedLocalFolderPathStr+'Readme.md '+DocumentDocumentLocalFolderPathStr+self.DocumentedConceptModuleStr.split('.')[-1]+'.md' ) if self.DocumentingSiteDocumentIsBool: #open os.popen( 'mkdocs build --clean' ) #deploy try: self.deploy( _ClientFilePathStrToServerFilePathStrOrderedDict=collections.OrderedDict( [ ( self.DocumentedSlideLocalFilePathStr, DocumentOntologyOuvatonFolderPathStr+self.DocumentedConceptModule.__name__.split('.' )[-1]+'.php' ) ] ) ) except: print('There is NO Internet !')
def do_neurongroup( self ): #/########################/# # Import brian # adapt the shape of the NeurongroupingBrianDict #debug ''' self.debug( [ 'We adapt the shape of NeurongroupingBrianDict', ('self.',self,[ 'NeurongroupingBrianDict' ]) ] ) ''' #Check if 'N' not in self.NeurongroupingBrianDict: self.NeurongroupingBrianDict['N']=self.SimulatingUnitsInt else: self.SimulatingUnitsInt=self.NeurongroupingBrianDict['N'] #Check if 'model' not in self.NeurongroupingBrianDict: self.NeurongroupingBrianDict['model']='' #/##################/# # Set finally the Neurongroup # #Check if self.NeurongroupingBrianDict['model']!="" or self.NeurongroupingBrianDict['N']>0: #maybe should import from brian2 import NeuronGroup #debug self.debug( [ 'We set the Neurongroup', ('self.',self,[ 'NeurongroupingBrianDict' ]) ] ) #init self.NeurongroupedBrianVariable=NeuronGroup( **self.NeurongroupingBrianDict ) else: #return return #/##################/# # team Traces first all the brian variables # #debug self.debug( [ 'We simulate with neurongroup', 'adapt the initial conditions of all the brian variables', 'so first we team Traces and put Tracers inside' ] ) #Check if 'Traces' not in self.TeamDict: NeurongroupedTracesDeriveTeamer=self.team( 'Traces' ).TeamedValueVariable else: NeurongroupedTracesDeriveTeamer=self.TeamDict[ 'Traces' ] #map self.NeurongroupedDeriveTracersList=map( lambda __TraceStr: NeurongroupedTracesDeriveTeamer.manage( Tracer.TracerPrefixStr+__TraceStr, { 'TracingKeyVariable':getattr( self.NeurongroupedBrianVariable, __TraceStr ), 'TraceKeyStr':__TraceStr } ).ManagedValueVariable, self.NeurongroupedBrianVariable.equations._equations.keys() ) #/##################/# # Now analyze the NeurongroupingStatesDict to set Moniters # #debug self.debug( [ 'We analyze the NeurongroupingStatesDict', ('self.',self,['NeurongroupingStatesDict']) ] ) #get NeurongroupedTracesMoniterKeyStrsList=Moniter.MoniterClass.DoingAttributeVariablesOrderedDict.keys() #map self.NeurongroupedDeriveMonitersList=SYS.flat( map( lambda __DeriveMoniter,__SampleTuplesList: map( lambda __SampleTuple: __DeriveMoniter.manage( __SampleTuple[0], SYS.match( NeurongroupedTracesMoniterKeyStrsList, __SampleTuple[1:] ) ).ManagedValueVariable, __SampleTuplesList ), map( lambda __KeyStr: NeurongroupedTracesDeriveTeamer.ManagementDict[ Tracer.TracerPrefixStr+__KeyStr ].team('Samples').TeamedValueVariable, self.NeurongroupingStatesDict.keys() ), self.NeurongroupingStatesDict.values() ) ) #/##################/# # Set Monitors inside # #Check if len(NeurongroupedTracesMoniterKeyStrsList)>0: #debug self.debug( [ 'We set the brian monitor inside' ] ) #import from brian2 import StateMonitor #map self.NeurongroupedDeriveStateMonitorsList=map( lambda __NeurongroupedDeriveMoniter: __NeurongroupedDeriveMoniter.set( 'MonitBrianVariable', StateMonitor( #NeuronGroup self.NeurongroupedBrianVariable, #varname __NeurongroupedDeriveMoniter.ParentDeriveTeamerVariable.ParentDeriveTeamerVariable.TraceKeyStr, #record __NeurongroupedDeriveMoniter.MoniteringLabelIndexIntsArray ) ).MonitBrianVariable, self.NeurongroupedDeriveMonitersList )
#Definition the AttestedStr print('MyNeurongrouper is ') SYS._print(MyNeurongrouper) #/###################/# # Do one simulation # #Print from brian2 import Network,ms,mV MyNetwork=Network() map( MyNetwork.add, SYS.flat( [ MyNeurongrouper.NeurongroupedBrianVariable, MyNeurongrouper.NeurongroupedSpikeMonitorsList, MyNeurongrouper.NeurongroupedStateMonitorsList ] ) ) #plot MyNeurongrouper.NeurongroupedBrianVariable.v=-55.*mV MyNetwork.run(500.*ms) M=MyNeurongrouper.NeurongroupedSpikeMonitorsList[0] from matplotlib import pyplot pyplot.plot(M.t/ms, M.i, '.') pyplot.show()
#ImportModules import ShareYourSystem as SYS #init MyList=[ [2,3], [3,4,[5,9]] ] #print print(SYS.sum(MyList)) #print print(SYS.flat(MyList)) #array MyArray=SYS.numpy.array( [ [2,3], [3,4] ] ) #print print(SYS.sum(MyArray)) #array MyArray=SYS.numpy.array( [ [[2,1],[3,5]], [[3],[4,66]]
def do_shape(self): #/################/# # Shaper is going to modify modeling description so keep an old version of this before # #keep a memory if self.ShapingDescriptionVariable==None: self.ShapingDescriptionVariable=copy.copy( self.ModelingDescriptionTuplesList ) else: self.ModelingDescriptionTuplesList=copy.copy(self.ShapingDescriptionVariable) #/################/# # Pick the shape ints and their get key strs # #debug ''' self.debug( [ 'We shape here', ("self.",self,['ShapingDimensionTuplesList']) ] ) ''' #Check if len(self.ShapingDimensionTuplesList)>0: #set [ self.ShapedDescriptionGetKeyStrsList, ShapedDescriptionDimensionGetTuplesList ]=SYS.unzip(self.ShapingDimensionTuplesList,[0,1]) #list self.ShapedDescriptionGetKeyStrsList=list(self.ShapedDescriptionGetKeyStrsList) #debug ''' self.debug( [ 'ShapedDescriptionDimensionGetTuplesList is ', str(ShapedDescriptionDimensionGetTuplesList) ] ) ''' #unzip self.ShapedDescriptionDimensionGetKeyStrsListsList=SYS.unzip( list(ShapedDescriptionDimensionGetTuplesList),[1] ) #debug self.debug( [ ('self.',self,['ShapedDescriptionDimensionGetKeyStrsListsList']) ] ) #get the corresponding real dimensions self.ShapedDescriptionDimensionIntsListsList=map( lambda __ShapedDescriptionDimensionGetKeyStrsList: self.ModelDeriveControllerVariable[Getter.GetMapStr]( *__ShapedDescriptionDimensionGetKeyStrsList ).ItemizedMapValueVariablesList, self.ShapedDescriptionDimensionGetKeyStrsListsList ) #debug ''' self.debug( [ ('self.',self,['ShapedDescriptionDimensionIntsListsList']) ] ) ''' else: #Default self.ShapedDescriptionGetKeyStrsList=[] self.ShapedDimensionGetKeyStrsList=[] self.ShapedDescriptionDimensionGetKeyStrsListsList=[] #debug ''' self.debug( [ ("self.",self,[ 'ShapedDescriptionGetKeyStrsList', 'ShapedDescriptionDimensionGetKeyStrsListsList', 'ShapedDescriptionDimensionIntsListsList' ]) ] ) ''' #/################/# # Find where in the description tuokes list it has to be modified and # #Definition ModeledGetKeyStrsList=SYS.unzip(self.ModelingDescriptionTuplesList,[0]) #set self.ShapedIndexIntsList=map( lambda __ShapedDescriptionGetKeyStr: ModeledGetKeyStrsList.index(__ShapedDescriptionGetKeyStr), self.ShapedDescriptionGetKeyStrsList ) #debug ''' self.debug( [ 'Check if we know already the modeler', 'self.ModelDeriveControllerVariable!=None is '+str( self.ModelDeriveControllerVariable!=None ) ] ) ''' #/################/# # set flat all the get key str for the shaping int # #Check if self.ModelDeriveControllerVariable!=None: #Flat and set self.ShapedDimensionGetKeyStrsList=list( set( SYS.flat( self.ShapedDescriptionDimensionGetKeyStrsListsList ) ) ) #Pick self.ShapedDimensionIntsList=self.ModelDeriveControllerVariable[Getter.GetMapStr ]( *self.ShapedDimensionGetKeyStrsList ).ItemizedMapValueVariablesList else: #Default self.ShapedDimensionIntsList=[] #/################/# # map a join str with this # #debug ''' self.debug(("self.",self,['ShapedDimensionIntsList'])) ''' #Bind with ModeledShapedStr setting self.ShapedStr=ShapeJoiningStr.join( map( lambda __ShapedDescriptionGetKeyStr,__ShapedDimensionVariable: ShapeJoiningStr+str( __ShapedDescriptionGetKeyStr )+ShapeTuplingStr+str( __ShapedDimensionVariable), self.ShapedDimensionGetKeyStrsList, self.ShapedDimensionIntsList ) ) #debug '''
def do_brian(self): #/###################/# # Flat the neurongroups and connections # #get self.BrianedDeriveNeurongroupersList=self.TeamDict[ BrianPopulationTeamKeyStr ].ManagementDict.values() #flat self.BrianedDeriveSynapsersList=SYS.flat( map( lambda __BrianedDeriveNeurongrouper: __BrianedDeriveNeurongrouper.TeamDict[ Neurongrouper.NeurongroupPostTeamKeyStr ].ManagementDict.values() if Neurongrouper.NeurongroupPostTeamKeyStr in __BrianedDeriveNeurongrouper.TeamDict else [], self.BrianedDeriveNeurongroupersList ) ) #debug """ self.debug( [ 'map(self.BrianedDeriveSynapsersList)' ('self',self,['BrianedDeriveSynapsersList']) ] ) """ """ #populate map( lambda __NetworkedDeriveConnecter: __NetworkedDeriveConnecter.populate(), self.NetworkedDeriveConnectersList ) """ """ #set the different times self.BrianedStepTimeFloatsList=list( set( SYS.flat( map( lambda __BrianingDerivePopulater: SYS.unzip( __BrianingDerivePopulater.MoniteringStateArgumentVariablesList, [2] ) if len( __BrianingDerivePopulater.MoniteringStateArgumentVariablesList )>0 else [], self.NetworkedDeriveConnectersList ) ) ) ) """ #debug ''' self.debug(('self.',self,['BrianedStepTimeFloatsList'])) ''' #import from brian2 import Clock,Network,ms #Check if self.BrianingTimeDimensionVariable==None: self.BrianingTimeDimensionVariable=ms #init self.BrianedNetworkVariable=Network() #set the clocks self.BrianedSimulationClock=Clock( dt=self.SimulatingStepTimeFloat*self.BrianingTimeDimensionVariable ) self.BrianedClocksDict=dict( map( lambda __BrianedStepTimeFloat: ( str(__BrianedStepTimeFloat), Clock( dt=__BrianedStepTimeFloat*self.BrianingTimeDimensionVariable ) ), self.BrianedStepTimeFloatsList ) ,**{ str( self.SimulatingStepTimeFloat ):self.BrianedSimulationClock } ) #debug ''' self.debug(('self.',self,['BrianedClocksDict'])) ''' #map populate and neurongroup self.BrianedNeuronGroupsList=map( lambda __BrianedDeriveNeurongrouper: __BrianedDeriveNeurongrouper.neurongroup( dict( { 'clock':self.BrianedSimulationClock, #Don't forget to replace the '/' by '_' because brian doesn't like them 'name':__BrianedDeriveNeurongrouper.ParentTagStr.replace( '/','_')+'_'+__BrianedDeriveNeurongrouper.ManagementTagStr }, **__BrianedDeriveNeurongrouper.NeurongroupingBrianKwargDict ) ).NeurongroupedBrianVariable, self.BrianedDeriveNeurongroupersList ) #map ''' map( lambda __BrianedNeuronGroup: __BrianedNeuronGroup.clock.__setattr__( 'dt', self.BrianedSimulationClock.dt ), self.BrianedNeuronGroupsList ) ''' #flat the spike monitors self.BrianedSpikeMonitorsList=SYS.flat( map( lambda __BrianedDerivePopulater: __BrianedDerivePopulater.NeurongroupedSpikeMonitorsList, self.BrianedDeriveNeurongroupersList ) ) #debug ''' self.debug(('self.',self,['BrianedSpikeMonitorsList'])) ''' #flat the state monitors self.BrianedStateMonitorsList=SYS.flat( map( lambda __BrianedDeriveNeurongrouper: __BrianedDeriveNeurongrouper.NeurongroupedStateMonitorsList, self.BrianedDeriveNeurongroupersList ) ) #debug ''' self.debug( [ ('self.',self,['BrianedStateMonitorsList']), 'Now we synapse...' ] ) ''' #map synapse self.BrianedSynapsesList=map( lambda __BrianedDeriveSynapser: __BrianedDeriveSynapser.synapse( dict( __BrianedDeriveSynapser.SynapsingKwargVariablesDict if __BrianedDeriveSynapser.SynapsingKwargVariablesDict!=None else {}, **{ 'source':__BrianedDeriveSynapser.CatchFromPointVariable.NeurongroupedBrianVariable, 'target':__BrianedDeriveSynapser.CatchToPointVariable.NeurongroupedBrianVariable, #'name':( # __BrianedDeriveSynapser.CatchFromPointVariable.NetworkKeyStr+'To'+__BrianedDeriveSynapser.CatchToPointVariable.NetworkKeyStr).replace('/','_') 'name':( __BrianedDeriveSynapser.SynapsingTagStr if __BrianedDeriveSynapser.SynapsingTagStr!="" else __BrianedDeriveSynapser.CatchKeyStr.replace('>','_').replace('<','_') ) } ) ).SynapsedBrianVariable, self.BrianedDeriveSynapsersList ) #debug ''' self.debug(('self.',self,['BrianedSynapsesList'])) ''' #map the add map( lambda __BrianedVariable: self.BrianedNetworkVariable.add(__BrianedVariable), self.BrianedNeuronGroupsList+self.BrianedSynapsesList+self.BrianedStateMonitorsList+self.BrianedSpikeMonitorsList ) """