# -*- coding: utf-8 -*-
"""
<DefineSource>
@Date : Fri Nov 14 13:20:38 2014 \n
@Author : Erwan Ledoux \n\n
</DefineSource>
A Parenter completes the list of grand-parent nodes that
a child node could have. It is a recursive top-down set
of the pointers and the pathStrs.
"""
#<DefineAugmentation>
import ShareYourSystem as SYS
BaseModuleStr="ShareYourSystem.Applyiers.Commander"
DecorationModuleStr="ShareYourSystem.Standards.Classors.Classer"
SYS.setSubModule(globals())
#</DefineAugmentation>
#<ImportSpecificModules>
import collections
from ShareYourSystem.Functers import Argumenter
#</ImportSpecificModules>
#<DefineLocals>
WalkingStr="zz"
#</DefineLocals>
#<DefineClass>
@DecorationClass()
class WalkerClass(BaseClass):
#Definition
RepresentingKeyStrsList=[
'WalkingSocketDict',
#'WalkedOrderedDict',
#'WalkedTopOrderedDict'
]
def default_init(self,
_WalkingSocketDict=None,
_WalkedOrderedDict=None,
_WalkedTopOrderedDict=None,
**_KwargVariablesDict
):
#Call the parent __init__ method
BaseClass.__init__(self,**_KwargVariablesDict)
def do_walk(self):
#Init the WalkedTopOrderedDict
WalkedTopOrderedDict=None
if 'IdStr' not in self.WalkingSocketDict:
#Definition the IdStr of this walk
IdStr=str(id(self.WalkingSocketDict))
#set the _WalkingSocketDict
self.WalkingSocketDict.update(
{
'IdStr':IdStr,
'TopVariable':self,
}
)
#Definition WalkedTopOrderedSetTagStr
WalkedTopOrderedSetTagStr='Walked'+WalkingStr+IdStr+WalkingStr+'OrderedDict'
#set the corresponding WalkedOrderedDict
self.__setattr__(
WalkedTopOrderedSetTagStr,
collections.OrderedDict(**
{
'IndexInt':-1,
'TopIntsList':['/'],
'TopVariablesList':[self]
}
)
)
#Alias this Dict
self.WalkedTopOrderedDict=getattr(
self,
WalkedTopOrderedSetTagStr
)
else:
#Get the information at the top
WalkedTopOrderedSetTagStr='Walked'+WalkingStr+self.WalkingSocketDict['IdStr']+WalkingStr+'OrderedDict'
self.WalkedTopOrderedDict=getattr(
self.WalkingSocketDict['TopVariable'],
WalkedTopOrderedSetTagStr
)
self.WalkedTopOrderedDict['IndexInt']+=1
self.WalkedTopOrderedDict['TopIntsList']+=[str(
self.WalkedTopOrderedDict['IndexInt'])]
self.WalkedTopOrderedDict['TopVariablesList']+=[self]
#An Update just before is possible
if 'BeforeUpdateList' in self.WalkingSocketDict:
#debug
'''
self.debug(('_SocketDict',_SocketDict,['BeforeUpdateList']))
'''
#Update
self.update(self.WalkingSocketDict['BeforeUpdateList'])
#Debug
'''
self.debug(('self.',self,['WalkingSocketDict']))
'''
#Command an recursive order in other gathered variables
self.command(
_UpdateList=[
('walk',{
'LiargVariablesList':[self.WalkingSocketDict],
}
)
],
**{
'GatheringVariablesList':self.WalkingSocketDict[
'GatherVariablesList'
]
}
)
#An Update just after is possible
if 'AfterUpdateList' in self.WalkingSocketDict:
self.update(self.WalkingSocketDict[
'AfterUpdateList'])
#Retrieve the previous Path
if len(self.WalkedTopOrderedDict['TopIntsList'])>0:
self.WalkedTopOrderedDict['TopIntsList']=self.WalkedTopOrderedDict[
'TopIntsList'][:-1]
self.WalkedTopOrderedDict['TopVariablesList']=self.WalkedTopOrderedDict[
'TopVariablesList'][:-1]
#Return self
if self.WalkingSocketDict['TopVariable']==self:
self.WalkedOrderedDict=WalkedTopOrderedDict
del self[WalkedTopOrderedSetTagStr]
return self
#</DefineClass>
View the Walker sources on Github
In [3]:
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Standards.Walkers import Walker
#Definition a Walker instance with a noded tree
MyWalker=Walker.WalkerClass().update(
[
(
'<Tree>FirstChildWalker',
Walker.WalkerClass().update(
[
(
'<Tree>GrandChildWalker',
Walker.WalkerClass()
)
]
)
),
(
'<Tree>SecondChildWalker',
Walker.WalkerClass()
)
]
)
#Walk inside the Tree in order to parent again because the tree was not yet completely setted when it was done
MyWalker.walk(
{
'BeforeUpdateList':
[
('SwitchingParentBool',False),
('parent',{'LiargVariablesList':['Tree']})
],
'GatherVariablesList':['<Tree>']
}
)
#Definition the AttestedStr
SYS._attest(
[
'MyWalker is '+SYS._str(
MyWalker,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False,
'RepresentingKeyStrsList':['ParentedDeriveParentersList']
}
)
]
)
#Print
# -*- coding: utf-8 -*-
"""
<DefineSource>
@Date : Fri Nov 14 13:20:38 2014 \n
@Author : Erwan Ledoux \n\n
</DefineSource>
A Cumulater pick and
"""
#<DefineAugmentation>
import ShareYourSystem as SYS
BaseModuleStr="ShareYourSystem.Standards.Walkers.Walker"
DecorationModuleStr="ShareYourSystem.Standards.Classors.Classer"
SYS.setSubModule(globals())
#</DefineAugmentation>
#<ImportSpecificModules>
import copy
#</ImportSpecificModules>
#<DefineClass>
@DecorationClass()
class CumulaterClass(BaseClass):
#Definition
RepresentingKeyStrsList=[
'CumulatedVariablesList'
]
def default_init(self,
_CumulatedVariablesList=None,
**_KwargVariablesDict):
#Call the parent __init__ method
BaseClass.__init__(self,**_KwargVariablesDict)
def do_cumulate(self):
#debug
'''
self.debug(('self.',self,[
'WalkingSocketDict',
'WalkedTopOrderedDict'
]))
'''
#Init
if 'CumulateVariablesList' not in self.WalkedTopOrderedDict:
self.WalkedTopOrderedDict['CumulateVariablesList']=[]
#debug
'''
self.debug(
('self.',self,[
'ConcludingConditionVariable',
])
)
'''
#Check
self.WalkedTopOrderedDict['CumulateVariablesList'].append(
self.filter('/').FilteredVariablesList
)
#debug
'''
self.debug(('self.',self,['FilteredVariablesList']))
'''
#set
if self.WalkingSocketDict['TopVariable']==self:
self.CumulatedVariablesList=self.WalkedTopOrderedDict['CumulateVariablesList']
#self.CumulatedVariablesList=copy.copy(self.WalkedTopOrderedDict['CumulateVariablesList'])
#</DefineClass>
View the Cumulater sources on Github
In [6]:
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Standards.Walkers import Cumulater
import operator
#Definition a Filter instance that is grouped
MyCumulater=Cumulater.CumulaterClass().update(
[
(
'<Filterome>FirstChildCumulater',
Cumulater.CumulaterClass().update(
[
(
'<Filterome>GrandChildFilter',
Cumulater.CumulaterClass()
)
]
)
),
(
'<Filterome>SecondChildFilter',
Cumulater.CumulaterClass()
),
(
'<Filterome>ThirdChildFilter',
Cumulater.CumulaterClass()
)
]
)
#Walk inside the group in order to parent
MyCumulater.walk(
{
'BeforeUpdateList':
[
(
'ConcludingConditionVariable',[
(
'NodeIndexInt',
lambda _TestInt,_AttestInt:
operator.lt(_TestInt,_AttestInt) and operator.lt(-1,_TestInt)
if _TestInt!=None else False,
2
)
]
),
(
'PickingKeyVariablesList',['NodeKeyStr']
),
('cumulate',{'LiargVariablesList':[]})
],
'GatherVariablesList':['<Filterome>']
}
)
#Definition the AttestedStr
SYS._attest(
[
'MyCumulater is '+SYS._str(
MyCumulater,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
#Print
# -*- coding: utf-8 -*-
"""
<DefineSource>
@Date : Fri Nov 14 13:20:38 2014 \n
@Author : Erwan Ledoux \n\n
</DefineSource>
A Visiter
"""
#<DefineAugmentation>
import ShareYourSystem as SYS
BaseModuleStr="ShareYourSystem.Standards.Walkers.Cumulater"
DecorationModuleStr="ShareYourSystem.Standards.Classors.Classer"
SYS.setSubModule(globals())
#</DefineAugmentation>
#<ImportSpecificModules>
from ShareYourSystem.Standards.Noders import Noder
#</ImportSpecificModules>
#<DefineClass>
@DecorationClass()
class VisiterClass(BaseClass):
#Definition
RepresentingKeyStrsList=[
'VisitingCollectionStrsList',
'VisitingBeforeUpdateList',
'VisitingAfterUpdateList'
]
def default_init(self,
_VisitingCollectionStrsList=None,
_VisitingBeforeUpdateList=None,
_VisitingAfterUpdateList=None,
**_KwargVariablesDict
):
#Call the parent __init__ method
BaseClass.__init__(self,**_KwargVariablesDict)
def do_visit(self):
#Walk inside the group in order to parent
self.walk(
{
'BeforeUpdateList':self.VisitingBeforeUpdateList,
'AfterUpdateList':self.VisitingAfterUpdateList,
'GatherVariablesList':map(
lambda __NodeCollectionStr:
Noder.NodingPrefixGetStr+__NodeCollectionStr+Noder.NodingSuffixGetStr,
self.VisitingCollectionStrsList
)
}
)
#</DefineClass>
View the Visiter sources on Github
In [9]:
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Standards.Walkers import Cumulater,Visiter
#Definition a Visiter instance that is grouped
MyVisiter=Visiter.VisiterClass().update(
[
(
'<Visitome>FirstChildVisiter',
Visiter.VisiterClass().update(
[
(
'<Collectome>GrandChildCumulater',
Cumulater.CumulaterClass()
)
]
)
),
(
'<Visitome>SecondChildVisiter',
Visiter.VisiterClass()
)
]
)
#Walk inside the group in order to parent
MyVisiter.visit(['Visitome','Collectome'],[('TagStr','Je suis passe par la')])
#Definition the AttestedStr
SYS._attest(
[
'MyVisiter is '+SYS._str(
MyVisiter,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
#Print
# -*- coding: utf-8 -*-
"""
<DefineSource>
@Date : Fri Nov 14 13:20:38 2014 \n
@Author : Erwan Ledoux \n\n
</DefineSource>
A Recruiter
"""
#<DefineAugmentation>
import ShareYourSystem as SYS
BaseModuleStr="ShareYourSystem.Standards.Walkers.Visiter"
DecorationModuleStr="ShareYourSystem.Standards.Classors.Classer"
SYS.setSubModule(globals())
#</DefineAugmentation>
#<ImportSpecificModules>
from ShareYourSystem.Standards.Noders import Noder
#</ImportSpecificModules>
#<DefineClass>
@DecorationClass()
class RecruiterClass(BaseClass):
#Definition
RepresentingKeyStrsList=[
'RecruitingConcludeConditionVariable',
'RecruitedFlatCumulateVariablesList'
]
def default_init(self,
_RecruitingConcludeConditionVariable=None,
_RecruitedFlatCumulateVariablesList=None,
**_KwargVariablesDict
):
#Call the parent __init__ method
BaseClass.__init__(self,**_KwargVariablesDict)
def do_recruit(self):
#Check
if type(self.VisitingBeforeUpdateList)!=list:
self.VisitingBeforeUpdateList=[]
#add
self.VisitingBeforeUpdateList+=[
(
'PickingKeyVariablesList',['/']
),
(
'ConcludingConditionVariable',
self.RecruitingConcludeConditionVariable
),
('cumulate',{'LiargVariablesList':[]})
]
#visit
self.visit()
#flat
self.RecruitedFlatCumulateVariablesList=SYS.filterNone(SYS.flat(
self.CumulatedVariablesList
)
)
#</DefineClass>
View the Recruiter sources on Github
In [12]:
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Standards.Walkers import Cumulater,Recruiter
import operator
#Definition a Recruiter instance that is grouped
MyRecruiter=Recruiter.RecruiterClass().update(
[
(
'<Visitome>FirstChildRecruiter',
Recruiter.RecruiterClass().update(
[
(
'<Collectome>GrandChildCumulater',
Cumulater.CumulaterClass()
)
]
)
),
(
'<Visitome>SecondChildRecruiter',
Recruiter.RecruiterClass()
),
(
'<Visitome>ThirdChildRecruiter',
Recruiter.RecruiterClass()
)
]
)
#Walk inside the group in order to parent
MyRecruiter.recruit(
[
(
'NodeIndexInt',
lambda _TestIndexInt,_AttestIndexInt:operator.lt(_TestIndexInt,_AttestIndexInt)
if _TestIndexInt!=None else False,
2
)
],
**{'VisitingCollectionStrsList':['Visitome','Collectome']}
)
#Definition the AttestedStr
SYS._attest(
[
'MyRecruiter is '+SYS._str(
MyRecruiter,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
#Print
# -*- coding: utf-8 -*-
"""
<DefineSource>
@Date : Fri Nov 14 13:20:38 2014 \n
@Author : Erwan Ledoux \n\n
</DefineSource>
A Mobilizer
"""
#<DefineAugmentation>
import ShareYourSystem as SYS
BaseModuleStr="ShareYourSystem.Standards.Walkers.Recruiter"
DecorationModuleStr="ShareYourSystem.Standards.Classors.Classer"
SYS.setSubModule(globals())
#</DefineAugmentation>
#<ImportSpecificModules>
from ShareYourSystem.Standards.Classors import Deriver
from ShareYourSystem.Standards.Noders import Noder
#</ImportSpecificModules>
#<DefineFunctions>
def getMobilizedIsBoolWithParentClassAndDeriveClassesList(
_ParentClass,_DeriveClassesList):
#Debug
'''
print('Mobilizer l.37')
print('_ParentClass is ',_ParentClass)
print('_DeriveClassesList is ',_DeriveClassesList)
print('')
'''
#Return
return any(
map(
lambda __DeriveClass:
Deriver.getIsDerivedBoolWithParentClassAndDeriveClass(
_ParentClass,
__DeriveClass
),
_DeriveClassesList
)
)
#<DefineFunctions>
#<DefineClass>
@DecorationClass()
class MobilizerClass(BaseClass):
#Definition
RepresentingKeyStrsList=[
'MobilizingNameStrsList'
]
def default_init(self,
_MobilizingNameStrsList=None,
_MobilizingCollectionSuffixStr="Figurome",
_MobilizedAttestClassesList=None,
**_KwargVariablesDict
):
#Call the parent __init__ method
BaseClass.__init__(self,**_KwargVariablesDict)
def do_mobilize(self):
#Check
if self.VisitingCollectionStrsList==None:
self.VisitingCollectionStrsList=[
self.CollectingCollectionStr
]
#map
self.MobilizedAttestClassesList=map(
SYS.getClassWithNameStr,
self.MobilizingNameStrsList
)
#debug
'''
self.debug(('self.',self,['MobilizedAttestClassesList']))
'''
#append
self.RecruitingConcludeConditionVariable.append(
(
'__class__',
getMobilizedIsBoolWithParentClassAndDeriveClassesList,
self.MobilizedAttestClassesList
)
)
#debug
'''
self.debug(('self.',self,['RecruitingConcludeConditionVariable']))
'''
#recruit
self.recruit()
#debug
'''
self.debug(('self.',self,['RecruitedFlatCumulateVariablesList']))
'''
#Split the different names into different collections
map(
lambda __RecruitedFlatCollectVariable:
self.grasp(
__RecruitedFlatCollectVariable
).catch(
__RecruitedFlatCollectVariable.__class__.NameStr+self.MobilizingCollectionSuffixStr,
),
self.RecruitedFlatCumulateVariablesList
)
#</DefineClass>
View the Mobilizer sources on Github
In [15]:
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Standards.Walkers import Visiter,Recruiter,Mobilizer
import operator
#Definition a Mobilizer instance that is grouped
MyMobilizer=Mobilizer.MobilizerClass().update(
[
(
'<Mobilizome>FirstChildMobilizer',
Mobilizer.MobilizerClass().update(
[
(
'<Recruitome>GrandChildRecruiter',
Recruiter.RecruiterClass()
),
(
'<Recruitome>FakeGrandChildVisiter',
Visiter.VisiterClass()
)
]
)
),
(
'<Mobilizome>SecondChildMobilizer',
Mobilizer.MobilizerClass()
),
(
'<Mobilizome>ThirdChildMobilizer',
Mobilizer.MobilizerClass()
)
]
)
#Walk inside the group in order to parent
MyMobilizer.mobilize(
[
'Mobilizer','Recruiter'
],
**{
'VisitingCollectionStrsList':['Mobilizome','Recruitome'],
'RecruitingConcludeConditionVariable':[
('NodeIndexInt',lambda _TestInt,_AttestInt:
_TestInt!=None and operator.lt(_TestInt,_AttestInt),2)
]
}
)
#Definition the AttestedStr
SYS._attest(
[
'MyMobilizer is '+SYS._str(
MyMobilizer,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
#Print
# -*- coding: utf-8 -*-
"""
<DefineSource>
@Date : Fri Nov 14 13:20:38 2014 \n
@Author : Erwan Ledoux \n\n
</DefineSource>
A Router
"""
#<DefineAugmentation>
import ShareYourSystem as SYS
BaseModuleStr="ShareYourSystem.Standards.Walkers.Mobilizer"
DecorationModuleStr="ShareYourSystem.Standards.Classors.Classer"
SYS.setSubModule(globals())
#</DefineAugmentation>
#<ImportSpecificModules>
import copy
import collections
from ShareYourSystem.Standards.Itemizers import Pather
#</ImportSpecificModules>
#<DefineClass>
@DecorationClass()
class RouterClass(BaseClass):
#Definition
RepresentingKeyStrsList=[
'RoutingPickKeyVariablesList',
'RoutedVariablesOrderedDict'
]
def default_init(self,
_RoutingPickKeyVariablesList=None,
_RoutedVariablesOrderedDict=None,
**_KwargVariablesDict):
#Call the parent __init__ method
BaseClass.__init__(self,**_KwargVariablesDict)
def do_route(self):
#debug
'''
self.debug(('self.',self,['WalkingSocketDict','WalkedTopOrderedDict']))
'''
#Init
if 'RouteTopOrderedDict' not in self.WalkedTopOrderedDict:
self.WalkedTopOrderedDict['RouteTopOrderedDict']=self.WalkingSocketDict['TopVariable'].RoutedVariablesOrderedDict
#Init
if 'PickKeyVariablesList' not in self.WalkedTopOrderedDict:
self.WalkedTopOrderedDict['PickKeyVariablesList']=self.WalkingSocketDict['TopVariable'].RoutingPickKeyVariablesList
#Pick and set in the dict
RouteVariablesOrderedDict=collections.OrderedDict()
map(
lambda __PickKeyVariable,__PickValueVariable:
RouteVariablesOrderedDict.update(
{__PickKeyVariable:__PickValueVariable}
),
self.WalkedTopOrderedDict['PickKeyVariablesList'],
self.pick(self.WalkedTopOrderedDict['PickKeyVariablesList'])
)
#debug
'''
self.debug(
(
'self.WalkedTopOrderedDict ',
self.WalkedTopOrderedDict,
[
'RouteTopOrderedDict',
'TopIntsList'
]
)
)
'''
#set
Pather.setWithPathVariableAndKeyVariable(
self.WalkedTopOrderedDict['RouteTopOrderedDict'],
self.WalkedTopOrderedDict['TopIntsList'],
RouteVariablesOrderedDict
)
#debug
'''
self.debug(
[
'After set...',
(
'self.WalkedTopOrderedDict ',
self.WalkedTopOrderedDict,
['RouteTopOrderedDict']
)
]
)
'''
#</DefineClass>
View the Router sources on Github
In [18]:
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Standards.Walkers import Router
#Definition a Router instance that has Tree nodes
MyRouter=Router.RouterClass().update(
[
(
'<Tree>FirstChildRouter',
Router.RouterClass().update(
[
(
'<Tree>GrandChildRouter',
Router.RouterClass()
)
]
)
),
(
'<Tree>SecondChildRouter',
Router.RouterClass()
)
]
)
#Walk inside the Tree in order to parent
MyRouter.walk(
{
'BeforeUpdateList':
[
('route',{'LiargVariablesList':[
['NodedTreeInt','NodedTreeKeyStr']
#['/']
]
})
],
'GatherVariablesList':['<Tree>']
}
)
#Definition the AttestedStr
SYS._attest(
[
'MyRouter is '+SYS._str(
MyRouter,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
#Print
# -*- coding: utf-8 -*-
"""
<DefineSource>
@Date : Fri Nov 14 13:20:38 2014 \n
@Author : Erwan Ledoux \n\n
</DefineSource>
A Grabber
"""
#<DefineAugmentation>
import ShareYourSystem as SYS
BaseModuleStr="ShareYourSystem.Standards.Walkers.Router"
DecorationModuleStr="ShareYourSystem.Standards.Classors.Classer"
SYS.setSubModule(globals())
#</DefineAugmentation>
#<ImportSpecificModules>
import copy
import collections
from ShareYourSystem.Functers import Argumenter
from ShareYourSystem.Standards.Noders import Noder
#</ImportSpecificModules>
#<DefineLocals>
#</DefineLocals>
#<DefineClass>
@DecorationClass()
class GrabberClass(BaseClass):
#Definition
RepresentingKeyStrsList=[
'GrabbingNodeStr',
'GrabbingPickVariablesList',
'GrabbedVariablesOrderedDict'
]
def default_init(self,
_GrabbingNodeStr=None,
_GrabbingPickVariablesList=None,
_GrabbedVariablesOrderedDict=None,
**_KwargVariablesDict):
#Call the parent __init__ method
BaseClass.__init__(self,**_KwargVariablesDict)
#@Argumenter.ArgumenterClass()
def do_grab(self):
#Init
if self.GrabbedVariablesOrderedDict==None:
self.GrabbedVariablesOrderedDict=collections.OrderedDict()
#debug
'''
self.debug(('self.',self,['GrabbingNodeStr','GrabbingPickVariablesList']))
'''
#Walk inside the Tree in order to parent
self.walk(
{
'BeforeUpdateList':
[
('route',{'LiargVariablesList':[
self.GrabbingPickVariablesList
]
})
],
'GatherVariablesList':[
Noder.NodingPrefixGetStr+self.GrabbingNodeStr+Noder.NodingSuffixGetStr]
}
)
#Link
self.GrabbedVariablesOrderedDict=self.RoutedVariablesOrderedDict
#</DefineClass>
View the Grabber sources on Github
In [21]:
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Standards.Walkers import Grabber
#Definition a Grabber instance that has Tree nodes
MyGrabber=Grabber.GrabberClass().update(
[
(
'<Tree>FirstChildGrabber',
Grabber.GrabberClass().update(
[
(
'<Tree>GrandChildGrabber',
Grabber.GrabberClass()
)
]
)
),
(
'<Tree>SecondChildGrabber',
Grabber.GrabberClass()
)
]
)
#Grab
MyGrabber.grab("Tree",['NodedTreeInt','NodedTreeKeyStr'])
#Definition the AttestedStr
SYS._attest(
[
'MyGrabber is '+SYS._str(
MyGrabber,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
#Print