def rowAfter(self,**_RowingVariablesList):
#debug
self.debug('Start of the method')
#debug
self.debug('Look if we have to make row first the noded children')
#IsNodingInsertingBool
if 'IsNodingRowingBool' not in _InsertingVariablesList or _InsertingVariablesList['IsNodingInsertingBool']:
#debug
self.debug(
[
'We are going to make row all the joined noded children',
'ModelStr is '+str(ModelStr)
]
)
#Row each noded children
map(
lambda __Variable:
__Variable.row(ModelStr),
self.ModeledDict['JoinedNodifiedOrderedDict'].values()
)
#debug
self.debug(
[
'The noded children have inserted'
]
)
#debug
self.debug(
[
"self.ModeledDict['ModelStr'] is "+str(self.ModeledDict['ModelStr'])
"We are going to check if the joined model is already inserted...",
"First look if JoinedModeledDict!={} is "+str(len(JoinedModeledDict)>0)
]
)
#Alias
JoinedModeledDict=self.ModeledDict['JoinedModeledDict']
#Check
if len(JoinedModeledDict)>0:
#debug
self.debug("Ok there is some not empty JoinedModeledDict here")
#set JoinedRetrievingIndexesListKeyStr
JoinedRetrievingIndexesListKeyStr=self.ModeledDict['JoinedRetrievingIndexesListKeyStr']
#Definition the GettingStrsList and the GettedVariablesList
if 'ColumningTuplesList' in JoinedModeledDict:
#debug
self.debug('Check that this joined row is a new row in the table or not')
#Get the GettingStrsList and GettedVariablesList
GettingStrsList=SYS.unzip(JoinedModeledDict['ColumningTuplesList'],[0])
GettedVariablesList=self.pick(GettingStrsList)
#Check if it was already rowed
IsRowedBoolsList=map(
lambda __Row:
all(
map(
lambda __GettingStr,__GettedVariable:
SYS.getIsEqualBool(__Row[__GettingStr],__GettedVariable),
GettingStrsList,
GettedVariablesList
)
),
JoinedModeledDict['TabledTable'].iterrows()
)
#debug
self.debug(
[
'self.StructuredKeyStr is '+str(
self.StructuredKeyStr) if hasattr(self,'StructuredKeyStr') else "",
'IsRowedBoolsList is '+str(IsRowedBoolsList)
]
)
#If it is rowed then set the JoinedRetrievingIndexesList
try:
RowInt=IsRowedBoolsList.index(True)
except ValueError:
RowInt=-1
#debug
self.debug('So the corresponding RowInt is '+str(RowInt))
#set the RowInt
self.ModeledDict['JoinedOrderedDict'][JoinedRetrievingIndexesListKeyStr][1]=RowInt
#Alias
JoinedOrderedDict=self.ModeledDict['JoinedOrderedDict']
JoinedRetrievingIndexesList=self.ModeledDict['JoinedOrderedDict'][JoinedRetrievingIndexesListKeyStr]
JoinedNodifiedNodeStr=self.ModeledDict['JoinedNodifiedNodeStr']
JoinedNodifiedNodedStr=self.ModeledDict['JoinedNodifiedNodedStr']
#Give the JoinedRetrievingIndexesList to itself
JoinedOrderedDict.__setitem__(
JoinedRetrievingIndexesListKeyStr,
JoinedRetrievingIndexesList
)
#debug
self.debug(
[
'JoinedOrderedDict is now',
SYS.represent(JoinedOrderedDict)
]
)
#Give to the parent
if JoinedNodifiedNodeStr!="":
ParentPointer=getattr(
self,
JoinedNodifiedNodedStr+'ParentPointer'
)
if ParentPointer!=None:
ParentPointer['App_Model_'+ModelingStr+'Dict']['JoinedOrderedDict'][
getattr(
self,
JoinedNodifiedNodedStr+'KeyStr'
)+JoinedRetrievingIndexesListKeyStr
]=JoinedRetrievingIndexesList
#Update the self.RowedIdentifiedOrderedDic
self.ModeledDict['RowedIdentifiedOrderedDict'].update(JoinedOrderedDict)
#debug
self.debug('End of the method')
def do_row(self):
""""""
#debug
'''
self.debug(
[
'We row here'
]
)
'''
#Check
if self.ModeledParentControllerDeriveModelerVariable!=None:
#debug
'''
self.ModeledParentControllerDeriveModelerVariable.debug('ParentSpeaking...')
'''
#Check
if self.ModelMongoBool:
#Update
self.RowedMongoPickOrderedDict.update(
zip(
self.RowingKeyStrsList,
#self.ModeledParentControllerDeriveModelerVariable[Getter.GetMapStr](
# *self.ModelKeyStrsList
#).ItemizedMapValueVariablesList
self.ModeledParentControllerDeriveModelerVariable.mapGet(
self.ModelKeyStrsList
)
)
)
#debug
'''
self.debug(
[
('self.',self,[
'RowedMongoPickOrderedDict',
'ModeledMongoCollection'
]
),
'list(self.ModeledMongoCollection.find()) is '+SYS._str(
list(self.ModeledMongoCollection.find()))
]
)
'''
#Check if it was already rowed
self.RowedMongoIsBoolsList=map(
lambda __Row:
all(
map(
lambda __RowedItemTuple:
SYS.getIsEqualBool(
__Row[__RowedItemTuple[0]],
__RowedItemTuple[1]
),
self.RowedMongoPickOrderedDict.items()
)
),
self.ModeledMongoCollection.find()
)
#debug
'''
self.debug(
[
('self.',self,[
'RowedMongoIsBoolsList'
]),
'Maybe there is now row or no rowing Key str ...so it is false already',
'len(self.RowedMongoIsBoolsList)==0 is ',
str(len(self.RowedMongoIsBoolsList)==0),
'len(self.RowedMongoPickOrderedDict)==0 is',
str(len(self.RowedMongoPickOrderedDict))
]
)
'''
#set
if len(self.RowedMongoIsBoolsList)==0 or len(self.RowedMongoPickOrderedDict)==0:
self.RowedMongoIsBool=False
else:
self.RowedMongoIsBool=any(self.RowedMongoIsBoolsList)
#Init to the len of the table
self.RowedMongoIndexInt=len(self.RowedMongoIsBoolsList)
#debug
'''
self.debug(('self.',self,[
'RowedMongoIndexInt',
'RowedMongoIsBool'
]))
'''
#But maybe find a last index
if self.RowedMongoIsBool:
if len(self.RowedMongoIsBoolsList)>0:
self.RowedMongoIndexInt=self.RowedMongoIsBoolsList.index(True)
#debug
'''
self.debug(('self.',self,['RowedMongoIsBool','RowedMongoIndexInt']))
'''
#Check
if self.ModelHdfBool:
#debug
'''
self.debug('This is a hdf row here')
'''
#/##################/#
# First check the good size
#
if self.RowKeyStrToColumnStrOrderedDict==None or len(
self.ModelingDescriptionTuplesList)!=len(
self.RowKeyStrToColumnStrOrderedDict):
#Bind with RowGetStrToColumnStrOrderedDict setting
self.RowKeyStrToColumnStrOrderedDict=collections.OrderedDict(
map(
lambda _ModelingSealTuple:
(
_ModelingSealTuple[0],
_ModelingSealTuple[1]
),
self._ModelingDescriptionTuplesList
)
)
#Bind with
self.RowHdfColumnStrsList=map(
lambda __RowingKeyStr:
self.RowKeyStrToColumnStrOrderedDict[__RowingKeyStr],
self.RowingKeyStrsList
)
#/#################/#
# Pick the values to be rowed in the hdf variables
#
#debug
'''
self.debug(
('self.',self,[
'RowingKeyStrsList',
'RowHdfColumnStrsList'
])
)
'''
#Update
self.RowedHdfPickOrderedDict.update(
zip(
self.RowHdfColumnStrsList,
#self.ModeledParentControllerDeriveModelerVariable[Getter.GetMapStr](
# *self.RowingKeyStrsList
#).ItemizedMapValueVariablesList
self.ModeledParentControllerDeriveModelerVariable.mapGet(
self.RowingKeyStrsList
)
)
)
#debug
'''
self.debug(
[
'Ok we have almost end the row',
('self.',self,[
'RowedHdfPickOrderedDict',
]
),
'Check now if it is a new row'
]
)
'''
#/#################/#
# Check if it is a new row
#
#Check if it was already rowed
self.RowedHdfIsBoolsList=map(
lambda __Row:
all(
map(
lambda __RowedItemTuple:
SYS.getIsEqualBool(
__Row[__RowedItemTuple[0]],
__RowedItemTuple[1]
),
self.RowedHdfPickOrderedDict.items()
)
),
self.ModeledHdfTable.iterrows()
)
#debug
'''
self.debug(
[
'Is is a new row ?',
('self.',self,['RowedHdfIsBoolsList']),
'Maybe there is now row or no rowing Key str ...so it is false already',
'len(self.RowedHdfIsBoolsList)==0 is ',
str(len(self.RowedHdfIsBoolsList)==0),
'len(self.RowedHdfPickOrderedDict)==0 is',
str(len(self.RowedHdfPickOrderedDict))
]
)
'''
#set
if len(self.RowedHdfIsBoolsList)==0 or len(self.RowedHdfPickOrderedDict)==0:
self.RowedHdfIsBool=False
else:
self.RowedHdfIsBool=any(self.RowedHdfIsBoolsList)
#Init to the len of the table
self.RowedHdfIndexInt=self.ModeledHdfTable.nrows
#But maybe find a last index
if self.RowedHdfIsBool:
if len(self.RowedHdfIsBoolsList)>0:
self.RowedHdfIndexInt=self.RowedHdfIsBoolsList.index(True)
#debug
'''
def row(self,**_VariablesList):
#debug
self.debug('Start of the method')
#debug
self.debug(
[
"self.ModelingModelStr is "+str(self.ModelingModelStr),
"We are going to check if the joined model is already inserted...",
"First look if self.JoinedModeledDatabase!={} is "+str(len(self.JoinedModeledDatabase)>0)
]
)
#Check
if self.JoinedDatabasePointer!=None:
#debug
self.debug("Ok there is a self.JoinedDatabasePointer")
#Alias
JoinedRetrievingIndexesList=self.JoinedRetrievingIndexesList
JoinedRetrievingIndexesListKeyStr=self.JoinedRetrievingIndexesListKeyStr
#debug
self.debug('Check that this joined row is a new row in the table or not')
#Get the GettingStrsList and GettedVariablesList
GettingStrsList=SYS.unzip(self.JoinedModeledDatabase.ModelingColumningTuplesList,[0])
GettedVariablesList=self.pick(GettingStrsList)
#Check if it was already rowed
IsRowedBoolsList=map(
lambda __Row:
all(
map(
lambda __GettingStr,__GettedVariable:
SYS.getIsEqualBool(__Row[__GettingStr],__GettedVariable),
GettingStrsList,
GettedVariablesList
)
),
self.JoinedDatabasePointer.TabledTable.iterrows()
)
#debug
self.debug(
[
'self.StructuredKeyStr is '+str(
self.StructuredKeyStr) if hasattr(self,'StructuredKeyStr') else "",
'IsRowedBoolsList is '+str(IsRowedBoolsList)
]
)
#If it is rowed then set the JoinedRetrievingIndexesList
try:
RowInt=IsRowedBoolsList.index(True)
except ValueError:
RowInt=-1
#debug
self.debug('So the corresponding RowInt is '+str(RowInt))
#set the RowInt
JoinedRetrievingIndexesList[1]=RowInt
#self.ModeledDict['JoinedOrderedDict'][JoinedRetrievingIndexesListKeyStr][1]=RowInt
#Alias
'''
JoinedOrderedDict=self.ModeledDict['JoinedOrderedDict']
JoinedRetrievingIndexesList=self.ModeledDict['JoinedOrderedDict'][JoinedRetrievingIndexesListKeyStr]
#Give the JoinedRetrievingIndexesList to itself
JoinedOrderedDict.__setitem__(
JoinedRetrievingIndexesListKeyStr,
JoinedRetrievingIndexesList
)
'''
'''
#debug
self.debug(
[
'JoinedOrderedDict is now',
SYS.represent(JoinedOrderedDict)
]
)
'''
#debug
#self.debug('So we set the JoinedRetrievingIndexesList in the RowedIdentifiedOrderedDict')
#Update the self.RowedIdentifiedOrderedDic
#self.ModeledDict['RowedIdentifiedOrderedDict'].update(JoinedOrderedDict)
#self.ModeledDict['RowedIdentifiedOrderedDict'].__setitem__(
# JoinedRetrievingIndexesListKeyStr,
# JoinedRetrievingIndexesList
# )
#debug
self.debug('End of the method')
def rowAfter(self,**_RowingVariablesList):
#debug
self.debug('Start of the method')
#debug
DebuggingStr="self.ModeledDict['ModelStr'] is "+str(self.ModeledDict['ModelStr'])
DebuggingStr+='\nWe are going to check if this model is already inserted...'
self.debug(DebuggingStr)
#Alias
JoinedModeledDict=self.ModeledDict['JoinedModeledDict']
#Check
if JoinedModeledDict!={}:
#set JoinedRetrievingIndexesListKeyStr
JoinedRetrievingIndexesListKeyStr=self.ModeledDict['JoinedRetrievingIndexesListKeyStr']
#Definition the GettingStrsList and the GettedVariablesList
if 'ColumningTuplesList' in JoinedModeledDict:
#debug
self.debug('Check that this row is a new row in the table or not')
#Get the GettingStrsList and GettedVariablesList
GettingStrsList=SYS.unzip(JoinedModeledDict['ColumningTuplesList'],[0])
GettedVariablesList=self.pick(GettingStrsList)
#Check if it was already rowed
IsRowedBoolsList=map(
lambda __Row:
all(
map(
lambda __GettingStr,__GettedVariable:
SYS.getIsEqualBool(__Row[__GettingStr],__GettedVariable),
GettingStrsList,
GettedVariablesList
)
),
JoinedModeledDict['TabularedTable'].iterrows()
)
#debug
if hasattr(self,'StructuredKeyStr'):
self.debug('self.StructuredKeyStr is '+str(self.StructuredKeyStr))
self.debug('IsRowedBoolsList is '+str(IsRowedBoolsList))
#If it is rowed then set the JoinedRetrievingIndexesList
try:
RowInt=IsRowedBoolsList.index(True)
except ValueError:
RowInt=-1
#debug
self.debug('So the corresponding RowInt is '+str(RowInt))
#set the RowInt
self.ModeledDict['JoinedOrderedDict'][JoinedRetrievingIndexesListKeyStr][1]=RowInt
#Alias
JoinedOrderedDict=self.ModeledDict['JoinedOrderedDict']
JoinedRetrievingIndexesList=self.ModeledDict['JoinedOrderedDict'][JoinedRetrievingIndexesListKeyStr]
JoinedNodifiedNodeStr=self.ModeledDict['JoinedNodifiedNodeStr']
#Give the JoinedRetrievingIndexesList to itself
JoinedOrderedDict.__setitem__(
JoinedRetrievingIndexesListKeyStr,
JoinedRetrievingIndexesList
)
#debug
self.debug(
[
'JoinedOrderedDict is now',
SYS.represent(JoinedOrderedDict)
]
)
#Give to the parent
if JoinedNodifiedNodeStr!="":
ParentPointer=getattr(
self,
JoinedNodifiedNodedStr+'ParentPointer'
)
if ParentPointer!=None:
ParentPointer['App_Model_'+ModelingStr+'Dict']['JoinedOrderedDict'][
getattr(
self,
JoinedNodifiedNodedStr+'KeyStr'
)+JoinedRetrievingIndexesListKeyStr
]=JoinedRetrievingIndexesList
#Update the self.RowedIdentifiedOrderedDic
self.ModeledDict['RowedIdentifiedOrderedDict'].update(JoinedOrderedDict)
#debug
self.debug('End of the method')
def join(
self,
_ModelStr="",
**_LocalJoiningVariablesDict
):
#debug
print('Joiner join method')
print('_ModelStr is ',_ModelStr)
if hasattr(self,"StructuredKeyStr"):
print('self.StructuredKeyStr is ',self.StructuredKeyStr)
print('')
#Maybe we need to refresh some modeled and tabulared attributes
if _ModelStr!="":
#debug
'''
print('_ModelStr is ',_ModelStr)
print('')
'''
#row
self.tabular(_ModelStr)
else:
#set again the _ModelStr
_ModelStr=self.ModeledDict['ModelStr']
#Init maybe the _LocalJoiningVariablesDict
if 'IsJoiningBool' not in _LocalJoiningVariablesDict:
#set IsScanningBool to False
_LocalJoiningVariablesDict['IsJoiningBool']=False
#Refresh attributes
self.JoinedJoinedList=[-1,-1]
self.JoinedOrderedDict=collections.OrderedDict()
self.JoinedNodifiedOrderedDict=collections.OrderedDict()
#Init a default False IsCheckingJoiningBool
if 'IsCheckingJoiningBool' not in _LocalJoiningVariablesDict:
_LocalJoiningVariablesDict['IsCheckingJoiningBool']=True
#set the JoiningTuple
if 'JoiningTuple' not in _LocalJoiningVariablesDict:
#Case where there are joins
if 'JoiningTuple' in self.ModeledDict:
#set to the _LocalJoiningVariablesDict
_LocalJoiningVariablesDict['JoiningTuple']=self.ModeledDict['JoiningTuple']
#Maybe we have to structure
if self.IsGroupedBool==False:
#debug
'''
print('Join We have to structure first')
if hasattr(self,"StructuredKeyStr"):
print('self.StructuredKeyStr is ',self.StructuredKeyStr)
'''
#Structure
self.structure(self.ModeledDict['JoiningTuple'][0])
else:
#set a default
_LocalJoiningVariablesDict['JoiningTuple']=("","")
#Nodify if there is the nodified objects
if _LocalJoiningVariablesDict['IsJoiningBool']==False and _LocalJoiningVariablesDict['JoiningTuple'
][0]!="":
#debug
print('Joiner we are going to nodify the ',_LocalJoiningVariablesDict['JoiningTuple'][0])
if hasattr(self,'StructuredKeyStr'):
print('self.StructuredKeyStr is ',self.StructuredKeyStr)
print('')
#Nodify
self.nodify(_LocalJoiningVariablesDict['JoiningTuple'][0])
self.JoinedNodifiedOrderedDict=copy.copy(self.NodifiedOrderedDict)
self.JoinedNodifiedNodeStr=self.NodifiedNodeStr
self.JoinedNodifiedNodedStr=SYS.getDoneStrWithDoStr(self.NodifiedNodeStr)
self.JoinedNodifiedNodingStr=SYS.getDoneStrWithDoStr(self.NodifiedNodeStr)
#debug
print('self.JoinedNodifiedOrderedDict is ',self.JoinedNodifiedOrderedDict)
print('')
#debug
'''
print("_LocalJoiningVariablesDict['JoiningTuple'] is ",
_LocalJoiningVariablesDict['JoiningTuple'])
print('')
'''
#If there is a joined model
if len(self.JoinedNodifiedOrderedDict)==0 or _LocalJoiningVariablesDict['IsJoiningBool']:
#debug
'''
print('We have the right to join !')
print("_LocalJoiningVariablesDict['IsJoiningBool']",
_LocalJoiningVariablesDict['IsJoiningBool'])
print('self.ModeledDict is ',self.ModeledDict)
print('')
'''
#Tabular for the _JoiningRowingStr if JoiningTuple is not None
if _LocalJoiningVariablesDict['JoiningTuple'][1]!=None:
self.JoinedModelStr=_LocalJoiningVariablesDict['JoiningTuple'][1]
self.JoinedModeledStr=SYS.getDoneStrWithDoStr(self.JoinedModelStr)
self.tabular(self.JoinedModelStr)
self.JoinedModeledDict=copy.copy(self.ModeledDict)
self.JoinedModeledKeyStr=self.ModeledKeyStr
self.JoinedJoinedList[0]=self.ShapedTabularedInt
self.JoinedTabularedTable=self.TabularedTable
#debug
'''
print('self.JoinedModeledDict is ',self.JoinedModeledDict)
print('self.JoinedModeledKeyStr is ',self.JoinedModeledKeyStr)
print('self.JoinedJoinedList is ',self.JoinedJoinedList)
print('')
'''
#Check if the actual setup is already rowed
if _LocalJoiningVariablesDict['IsCheckingJoiningBool'] and self.JoinedJoinedList[1]==-1:
#Definition the GettingStrsList and the GettedVariablesList
if 'ColumningTuplesList' in self.JoinedModeledDict:
#Get the GettingStrsList and GettedVariablesList
GettingStrsList=SYS.unzip(self.JoinedModeledDict['ColumningTuplesList'],[0])
GettedVariablesList=self.pick(GettingStrsList)
#debug
'''
print(map(
lambda __Row:
map(
lambda __GettingStr,__GettedVariable:
all(__Row[__GettingStr]==__GettedVariable),
GettingStrsList,
GettedVariablesList
),
JoinedTabularedTable.iterrows()
)
)
'''
#Check if it was already rowed
IsRowedBoolsList=map(
lambda __Row:
all(
map(
lambda __GettingStr,__GettedVariable:
SYS.getIsEqualBool(__Row[__GettingStr],__GettedVariable),
GettingStrsList,
GettedVariablesList
)
),
self.JoinedTabularedTable.iterrows()
)
#debug
'''
print('self.StructuredKeyStr is ',self.StructuredKeyStr)
print('IsRowedBoolsList is ',IsRowedBoolsList)
print('')
'''
#If it is rowed then set the JoinedJoinedList
try:
IndexInt=IsRowedBoolsList.index(True)
except ValueError:
IndexInt=-1
self.JoinedJoinedList[1]=IndexInt
#Give to itself
JoinedOrderedSetTagStr=self.JoinedNodifiedNodedStr+'JoinedOrderedDict'
if hasattr(self,JoinedOrderedSetTagStr):
self.JoinedOrderedDict=getattr(self,JoinedOrderedSetTagStr)
if self.JoinedOrderedDict==None:
self.JoinedOrderedDict=collections.OrderedDict()
self.JoinedOrderedDict.__setitem__(
self.JoinedJoinedListKeyStr,self.JoinedJoinedList
)
if self.JoinedNodifiedNodedStr!="":
ParentPointer=getattr(self,self.JoinedNodifiedNodedStr+'ParentPointer')
if ParentPointer!=None:
#Give to the Parent
JoinedOrderedDict=getattr(ParentPointer,JoinedOrderedSetTagStr)
JoinedOrderedDict[getattr(self,self.JoinedNodifiedNodedStr+'KeyStr'
)+self.JoinedJoinedListKeyStr]=self.JoinedJoinedList
#debug
'''
print('JoinedModeledDict is ',JoinedModeledDict)
print('JoinedList is ',JoinedList)
print('')
'''
#Tabular again to set again the ModeledDict
self.tabular(_ModelStr)
else:
#debug
'''
print('This either a not last level of child or it is not yet authorized to join')
print('self.JoinedNodifiedOrderedDict.values() is ',self.JoinedNodifiedOrderedDict.values())
print('len(self.NodifiedOrderedDict.values()) is ',len(self.NodifiedOrderedDict.values()))
print("_LocalJoiningVariablesDict['IsJoiningBool']",_LocalJoiningVariablesDict['IsJoiningBool'])
print('so join the deeper children groups first')
print('')
'''
map(
lambda __JoiningObjects:
__JoiningObjects.join(
self.ModeledDict['ModelStr'],
**_LocalJoiningVariablesDict
),
self.JoinedNodifiedOrderedDict.values()
)
'''
print('The deeper children groups are joined now')
print('So join here !')
print('')
'''
self.join(
self.ModeledDict['ModelStr'],
**dict(
_LocalJoiningVariablesDict,**{'IsJoiningBool':True}
)
)
#Return self
return self
def recoverBefore(self,**_LocalRecoveringVariablesDict):
#debug
print('Joiner recoverBefore method')
print('self.RetrievedFilteredRowedDictsList is ')
SYS._print(self.RetrievedFilteredRowedDictsList)
if hasattr(self,'StructuredKeyStr'):
print("self['StructuredKeyStr'] is ",self.StructuredKeyStr)
print('')
if len(self.RetrievedFilteredRowedDictsList)==1:
#debug
'''
print('Joiner It is good, there is one solution !')
print('')
'''
#Definition a JoinedRecoveredDict
JoinedRecoveredDict=self.RetrievedFilteredRowedDictsList[0]
#debug
print('Joiner JoinedRecoveredDict is ')
SYS._print(JoinedRecoveredDict)
print('self.JoinedNodifiedNodedStr is ',self.JoinedNodifiedNodedStr)
if hasattr(self,'StructuredKeyStr'):
print("self['StructuredKeyStr'] is ",self.StructuredKeyStr)
print('')
#Maybe we have to recover the children before
ChildJoinersList=self.JoinedNodifiedOrderedDict.values()
if len(ChildJoinersList)>0:
#set each Children and recover each
JoinedNodifiedKeyStr=self.JoinedNodifiedNodedStr+'KeyStr'
#debug
print('We are going to make recover each children before')
if hasattr(self,'StructuredKeyStr'):
print('self.StructuredKeyStr is ',self.StructuredKeyStr)
print('')
print('self.JoinedNodifiedOrderedDict.values() is ',self.JoinedNodifiedOrderedDict.values())
print('')
#Map a Recover
map(
lambda __JoinedJoiner:
__JoinedJoiner.__setitem__(
'/App_Model_'+self.ModeledDict['ModelingStr']+'Dict/RetrievingIndexesListsList',
[
(
JoinStr+self.JoinedJoinedListKeyStr,
(
SYS.getIsEqualBool,
JoinedRecoveredDict[
self.JoinedNodifiedNodedStr+getattr(
__JoinedJoiner,
JoinedNodifiedKeyStr
)+self.JoinedJoinedListKeyStr
]
)
)
]
).recover(self.ModeledKeyStr),
ChildJoinersList
)
#Definition the
AppendingGettingStrsList=SYS.unzip(self.JoinedFilteredMergedRowedDictsListTuplesList,[0])
#debug
print('Joiner maybe update first the joined model')
print('self.JoinedFilteredMergedRowedDictsListTuplesList is')
SYS._print(self.JoinedFilteredMergedRowedDictsListTuplesList)
print('AppendingGettingStrsList is ',AppendingGettingStrsList)
#Next we have maybe to update with the joined model
if '/' in AppendingGettingStrsList:
#Definition the IndexInt of the joined model
IndexInt=AppendingGettingStrsList.index('/')
#Definition the JoinedFilteredMergedRowedDictsList
JoinedFilteredMergedRowedDictsList=self.JoinedFilteredMergedRowedDictsListTuplesList[
IndexInt][1]
#Definition the JoinedJoinedList
JoinedJoinedList=JoinedRecoveredDict[self.JoinedJoinedListKeyStr]
#debug
print('JoinedFilteredMergedRowedDictsList is ')
SYS._print(JoinedFilteredMergedRowedDictsList)
print('JoinedJoinedList is ',JoinedJoinedList)
if hasattr(self,'StructuredKeyStr'):
print("self['StructuredKeyStr'] is ",self.StructuredKeyStr)
print('')
#Take the first element of self.JoinedFilteredMergedRowedDictsTuplesList which corresponds to the Joined Model at this level
JoinedRowedDict=next(
RowedDict for RowedDict in JoinedFilteredMergedRowedDictsList
if SYS.getIsEqualBool(
RowedDict[self.JoinedJoinedListKeyStr],
JoinedJoinedList
)
)
#debug
'''
print('JoinedRowedDict is ',JoinedRowedDict)
print('')
'''
#Update
self.update(JoinedRowedDict.items())
else:
#debug
print('Joiner There are multiple retrieved states')
if hasattr(self,'StructuredKeyStr'):
print("self['StructuredKeyStr'] is ",self.StructuredKeyStr)
print('self.RetrievedFilteredRowedDictsList is ')
SYS._print(self.RetrievedFilteredRowedDictsList)
print('')
#Stop the recover
self.IsRecoveringBool=False
def do_row(self):
""""""
#debug
'''
self.debug('We row here')
'''
#Check
if self.ModelDeriveControllerVariable!=None:
#debug
'''
self.ModelDeriveControllerVariable.debug('ParentSpeaking...')
'''
#Check
if self.ModelingMongoBool:
#Update
self.RowedMongoPickOrderedDict.update(
zip(
self.RowingKeyStrsList,
self.ModelDeriveControllerVariable[Getter.GetMapStr](
*self.ModelKeyStrsList
).ItemizedMapValueVariablesList
)
)
#debug
'''
self.debug(
[
('self.',self,[
'RowedMongoPickOrderedDict',
'TabledMongoCollection'
]
),
'list(self.TabledMongoCollection.find()) is '+SYS._str(
list(self.TabledMongoCollection.find()))
]
)
'''
#Check if it was already rowed
self.RowedMongoIsBoolsList=map(
lambda __Row:
all(
map(
lambda __RowedItemTuple:
SYS.getIsEqualBool(
__Row[__RowedItemTuple[0]],
__RowedItemTuple[1]
),
self.RowedMongoPickOrderedDict.items()
)
),
self.TabledMongoCollection.find()
)
#debug
'''
self.debug(('self.',self,[
'RowedMongoIsBoolsList'
]))
'''
#set
if len(self.RowedMongoIsBoolsList)==0:
self.RowedMongoIsBool=False
else:
self.RowedMongoIsBool=any(self.RowedMongoIsBoolsList)
#Init to the len of the table
self.RowedMongoIndexInt=len(self.RowedMongoIsBoolsList)
#debug
'''
self.debug(('self.',self,[
'RowedMongoIndexInt',
'RowedMongoIsBool'
]))
'''
#But maybe find a last index
if self.RowedMongoIsBool:
if len(self.RowedMongoIsBoolsList)>0:
self.RowedMongoIndexInt=self.RowedMongoIsBoolsList.index(True)
#debug
'''
self.debug(('self.',self,['RowedMongoIsBool','RowedMongoIndexInt']))
'''
#Check
if self.ModelingHdfBool:
#debug
'''
self.debug('This is a hdf row here')
'''
#/#################/#
# Pick the values to be rowed in the hdf variables
#
#debug
'''
self.debug(
('self.',self,[
'RowingKeyStrsList',
'RowHdfColumnStrsList'
])
)
'''
#Update
self.RowedHdfPickOrderedDict.update(
zip(
self.RowHdfColumnStrsList,
self.ModelDeriveControllerVariable[Getter.GetMapStr](
*self.RowingKeyStrsList
).ItemizedMapValueVariablesList
)
)
#debug
'''
self.debug(
[
'Ok we have almost end the row',
('self.',self,[
'RowedHdfPickOrderedDict',
]
),
'Check now if it is a new row'
]
)
'''
#/#################/#
# Check if it is a new row
#
#Check if it was already rowed
self.RowedHdfIsBoolsList=map(
lambda __Row:
all(
map(
lambda __RowedItemTuple:
SYS.getIsEqualBool(
__Row[__RowedItemTuple[0]],
__RowedItemTuple[1]
),
self.RowedHdfPickOrderedDict.items()
)
),
self.TabledHdfTable.iterrows()
)
#debug
'''
self.debug(
[
('self.',self,['RowedHdfIsBoolsList'])
]
)
'''
#set
if len(self.RowedHdfIsBoolsList)==0:
self.RowedHdfIsBool=False
else:
self.RowedHdfIsBool=any(self.RowedHdfIsBoolsList)
#Init to the len of the table
self.RowedHdfIndexInt=self.TabledHdfTable.nrows
#But maybe find a last index
if self.RowedHdfIsBool:
if len(self.RowedHdfIsBoolsList)>0:
self.RowedHdfIndexInt=self.RowedHdfIsBoolsList.index(True)
#debug
'''