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
)
"""
