}) class MakerClass(object): def default_init(self, _MakingMyFloat=0., _MadeMyInt=0, **_KwarVariablesDict ): object.__init__(self,**_KwarVariablesDict) def do_make(self): #cast self.MadeMyInt=int(self.MakingMyFloat) #Definition the AttestedStr SYS._attest( [ 'MakerClass.make is '+str(MakerClass.make), 'MakerClass.DeriveClassor.ObservingWrapMethodStr is '+str( MakerClass.DeriveClassor.ObservingWrapMethodStr), 'MakerClass.DeriveClassor.ObservedWrapMethodStr is '+str( MakerClass.DeriveClassor.ObservedWrapMethodStr), ] ) #Print
SYS.GriderClass.__init__(self,**_KwargVariablesDict)
def do_multiply(self):
#set the MultipliedTotalInt
self.MultipliedTotalInt=self.MultiplyingFirstInt*self.MultiplyingSecondInt
MyMultiplier=MultiplierClass().grid(
[
('MultiplyingFirstInt',[0,1,2]),
('MultiplyingSecondInt',[2,4]),
]
)
#Definition the AttestedStr
SYS._attest(
[
'MyMultiplier is '+SYS._str(
MyMultiplier,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
),
'hdf5 file is : '+MyMultiplier.hdfview().hdfclose().HdformatedConsoleStr
]
)
#Print
"hello"
)
)
]
)
#Map some gets
GatheredVariablesList=MyGatherer.gather(
[
['MyInt'],
['/FirstChildGatherer/MyStr','/SecondChildGatherer/MyStr']
]
)
#Definition the AttestedStr
SYS._attest(
[
'GatheredVariablesList is '+SYS._str(
GatheredVariablesList
,**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
#Print
import ShareYourSystem as SYS
from ShareYourSystem.Noders import Settler
# Short expression and set in the appended manner
MySettler = (
Settler.SettlerClass()
.__setitem__("<Settlome>ChildSettler", Settler.SettlerClass())
.update(
[
("<Settlome>GrandFirstChildSettler", Settler.SettlerClass()),
(
"<Settlome>GrandSecondChildSettler",
Settler.SettlerClass(**{"SettlingParentBool": True, "SettlingLinkBool": True}).__setitem__(
"LinkingPointListsList",
[("/NodePointDeriveNoder/<Settlome>GrandFirstChildSettler", "GrandFirstChildSettler")],
),
),
]
)
)
# Definition the AttestedStr
SYS._attest(
[
"MySettler is "
+ SYS._str(MySettler, **{"RepresentingBaseKeyStrsListBool": False, "RepresentingAlineaIsBool": False})
]
)
# Print
import ShareYourSystem as SYS
from ShareYourSystem.Guiders import Documenter
#Definition a Documenter instance
MyDocumenter=Documenter.DocumenterClass().document(
True,
**{
'PackagingModuleVariable':'ShareYourSystem.Objects'
}
)
#Definition the AttestedStr
SYS._attest(
[
'MyDocumenter is '+SYS._str(
MyDocumenter,
**{
'RepresentingBaseKeyStrsListBool':False
}
)
]
)
#Print
)
#Walk to set the same structure in the hdf5
MyGrouper.walk(
{
'BeforeUpdateList':
[
('parent',{'LiargVariablesList':[['HdformatedFileVariable']]}),
('group',{'LiargVariablesList':[]})
],
'GatherVariablesList':['<Tree>']
}
).hdfclose()
#Definition the AttestedStr
SYS._attest(
[
'MyGrouper is '+SYS._str(
MyGrouper,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
),
'MyGrouper.hdfview().HdformatedConsoleStr is '+MyGrouper.hdfview().HdformatedConsoleStr
]
)
#Print
#DatabasingSealTuplesList
[
#GetStr #ColumnStr #Col
('MyInt','MyInt',tables.Int64Col()),
('MyStr','MyStr',tables.StringCol(10)),
('MyIntsList','MyIntsList',tables.Int64Col(shape=3))
]
)
#Definition the AttestedStr
SYS._attest(
[
'MyController is '+SYS._str(
MyController,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
),
'MyController["<Databasers>ThingsDatabaser"].DatabasedModelClass.__dict__ is '+SYS._str(
dict(MyController['<Databasers>ThingsDatabaser'].DatabasedModelClass.__dict__.items()
) if MyController['<Databasers>ThingsDatabaser'
].DatabasedModelClass!=None else {},**{'RepresentingAlineaIsBool':False}
)
]
)
#Print
)['<Joiners>ParametersJoiner'].insert()
#Update and insert in the results
MyModulizer.__setitem__(
"Dis_<Components>",
[
[
('MultiplyingFirstInt',2)
],
[
('MultiplyingSecondInt',4)
]
]
)['<Joiners>ParametersJoiner'].insert()
"""
#Definition the AttestedStr
SYS._attest(
[
'MyModulizer is '+SYS._str(
MyModulizer,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
"""
#print
# [
# {'SymbolStr':'1'},
# {'SymbolStr':'1'}
# ]
# )
}
)
).equation(
_CodeStr='''
double id(double t){
return 1.;
}
'''
)
'''
#Definition the AttestedStr
SYS._attest(
[
'MyEquationer is '+SYS._str(
MyEquationer,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
),
]
)
'''
#print
},
'MyStr':'hello'
}
}
#Represent a TuplesList
TuplesList=[
(
'ParentTuplesList',
[
(
'ChildDict',
{
'MyInt':0
}
)
]
),
('MyStr','hello')
]
#Definition the AttestedStr
SYS._attest(
[
'Dict is'+SYS._str(Dict),
'TuplesList is'+SYS._str(TuplesList)
]
)
#Print
if _TestInt!=None else False,
2
)
]
),
(
'PickingKeyVariablesList',['NodeKeyStr']
),
('cumulate',{'LiargVariablesList':[]})
],
'GatherVariablesList':['<Cumulaters>']
}
)
#Definition the AttestedStr
SYS._attest(
[
'MyCumulater is '+SYS._str(
MyCumulater.CumulatedVariablesList,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
#Print
[
"StateMoniters",
['Rate'],
SYS.MoniterClass,
{
'MoniteringVariableStr':'RatedPostFloatsList',
'MoniteringIndexIntsList':[0,1]
}
]
}
}
).rate()
#Definition the AttestedStr
SYS._attest(
[
'MyRater is '+SYS._str(
MyRater,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False,
'RepresentingKeyStrsList':[
]
}
),
]
)
#Print
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Specials.Simulaters import Dynamizer
#Definition an instance
MyDynamizer=Dynamizer.DynamizerClass().dynamize()
#Definition the AttestedStr
SYS._attest(
[
'MyDynamizer is '+SYS._str(
MyDynamizer,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False,
'RepresentingKeyStrsList':['PopulatingEquationStr','DynamizedPostStr']
}
),
]
)
#Print
#Init attributes
self.BuiltMyFloat=0.
#set the output hierarchy
self['<Output>MyMaker']=MakerClass()
@Outputer.OutputerClass()
def build(self):
#Print
print('I build then !')
#set
self.BuiltMyFloat=float(2*self['<Output>MyMaker'].MadeMyInt)
#Definition an instance
MyBuilder=BuilderClass().build()
#Definition the AttestedStr
SYS._attest(
[
'MyBuilder.BuiltMyFloat is '+str(MyBuilder.BuiltMyFloat)
]
)
#Print
#make once
MyMaker.make(3.)
#Print
print('After the first make, MyMaker is ')
SYS._print(MyMaker)
#Reset
print('Now we reset')
MyMaker.WatchMakeWithMakerBool=False
#Print
print('After the reset, MyMaker is ')
SYS._print(MyMaker)
#Definition the AttestedStr
SYS._attest(
[
'MakerClass.WatchMakeBoolWithMaker is '+str(MakerClass.WatchMakeWithMakerBool),
'MakerClass.setResetBoolWithMaker_ is '+str(MakerClass.setResetBoolWithMaker_),
'MakerClass.make is '+str(MakerClass.make),
'MyMaker is '+SYS._str(
MyMaker,**{'RepresentingAlineaIsBool':False}
),
]
)
#Print
@Imitater.ImitaterClass()
def make(self):
#Call the parent method
MakerClass.make(self)
#Do something more
self.MadeMyInt+=2
#Definition of a Builder instance that is going to make
MyBuilder=BuilderClass().make(3.)
#Definition the AttestedStr
SYS._attest(
[
'BuilderClass.make is '+str(BuilderClass.make),
'MyBuilder.__dict__ is '+SYS._str(
MyBuilder.__dict__,
**{
'RepresentingBaseKeyStrsListBool':False
}
)
]
)
#Print
print('I make')
#cast
self.MadeMyInt=int(self.MakingMyFloat)
#Definition and do a first make
MyMaker=MakerClass().make(3.)
#Use the other binded method that is completely fooooo
MyMaker.foo_make()
#Definition the AttestedStr
SYS._attest(
[
'MakerClass.foo is '+str(MakerClass.foo),
'MakerClass.foo_make is '+str(MakerClass.foo_make),
'MyMaker is '+SYS._str(
MyMaker,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
#Print
#ImportModules import ShareYourSystem as SYS from ShareYourSystem.Objects import Cloner #Definition of an instance Cloner MyCloner=Cloner.ClonerClass() MyCloner.MyInt=1 #clone MyFirstCloner=MyCloner.clone() MyFirstCloner.MyInt=2 #Definition the AttestedStr SYS._attest( [ 'MyCloner is '+SYS._str(MyCloner), 'MyFirstCloner is '+SYS._str(MyFirstCloner) ] ) #Print
#FrozenIsBool False
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Standards.Objects.Hdformater import Drafts
#Definition the AttestedStr
SYS._attest(
[
'DefaultAttributeItemTuplesList is '+SYS._str(
Drafts.DraftsClass.DefaultAttributeItemTuplesList,
**{'RepresentingAlineaIsBool':False}
)
]
)
#Print
self.MadeMyInt=int(self.MakingMyFloat)
#Definition an instance
MyMaker=MakerClass()
#Print
print('Before make, MyMaker is ')
_print(MyMaker)
#make once
MyMaker.make(3.)
#Print
print('After the first make, MyMaker is ')
_print(MyMaker)
#Definition the AttestedStr
SYS._attest(
[
'MakerClass.make is '+str(MakerClass.make),
'MyMaker is '+SYS._str(
MyMaker,**{'RepresentingAlineaIsBool':False}
),
]
)
#Print
#ImportModules import ShareYourSystem as SYS #Definition of a Packager instance and module MyPackager=SYS.PackagerClass().package( 'ShareYourSystem.Standards.Interfacers.Printer' ) #Definition the AttestedStr SYS._attest( [ 'MyPackager'+SYS._str(MyPackager) ] ) #Print
print('Now we switch all')
MyBuilder.setSwitch('make',BuilderClass)
#Print
print('After the switch MyBuilder.__dict__ is ')
SYS._print(MyBuilder.__dict__)
#make again
MyBuilder.make(7.)
#Print
print('After the third make, MyBuilder.__dict__ is ')
SYS._print(MyBuilder.__dict__)
#Definition the AttestedStr
SYS._attest(
[
'BuilderClass.WatchBeforeMakeWithMakerBool is '+str(BuilderClass.WatchBeforeMakeWithMakerBool),
'BuilderClass.make is '+str(BuilderClass.make),
'BuilderClass.build is '+str(BuilderClass.build),
'MyBuilder.__dict__ is '+SYS._str(
MyBuilder.__dict__
)
]
)
#Print
# set the FactorizedTotalFloat
self.FactorizedTotalFloat = np.power(
sum(map(lambda __DeriveSumer: __DeriveSumer.SumedTotalInt, self[self.OrganizedComponentsGetStr])),
self.FactorizingPowerFloat,
)
# Definition of a Factorizer
MyFactorizer = FactorizerClass().__setitem__(
"Dis_<Component>",
[
[("GridingScanTuplesList", [("SumingFirstInt", [1]), ("SumingSecondInt", [2, 4])])],
[("GridingScanTuplesList", [("SumingFirstInt", [0, 1]), ("SumingSecondInt", [3])])],
],
)
# grid
MyFactorizer.grid([("FactorizingPowerFloat", [1, 2])])
# Definition the AttestedStr
SYS._attest(
[
"MyFactorizer is "
+ SYS._str(MyFactorizer, **{"RepresentingBaseKeyStrsListBool": False, "RepresentingAlineaIsBool": False}),
"hdf5 file is : " + MyFactorizer.hdfview().hdfclose().HdformatedConsoleStr,
]
)
# Print
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Itemizers import Sharer
#Explicit expression
MySharer=Sharer.SharerClass().__setitem__(
'__class__.MyStr',
'I am setted at the level of the class'
)
#Return
SYS._attest(
[
'MySharer is '+SYS._str(
MySharer,
**{
'RepresentingBaseKeyStrsListBool':False
}
),
'MySharer.__class__.MyStr is '+MySharer.__class__.MyStr,
'MySharer["__class__.MyStr"] is '+MySharer['__class__.MyStr'],
]
)
#Print
'SynapsePreStr':'gi-=9*mV',
'SynapseProbabilityFloat':0.02
}
)
]
}
]
).brian()
#Definition the AttestedStr
SYS._attest(
[
'MyBrianer is '+SYS._str(
MyBrianer,
**{
'RepresentingBaseKeyStrsList':False,
'RepresentingAlineaIsBool':False
}
),
]
)
#SYS._print(MyBrianer.BrianedMonitorsList[0].__dict__)
#SYS._print(
# MyBrianer.BrianedNeuronGroupsList[0].__dict__
#)
#import matplotlib
#plot(MyBrianer['<Connectome>FirstRater'].)
MyModulizer.__setitem__(
"Dis_<Components>",
[
[
('MultiplyingFirstInt',2)
],
[
('MultiplyingSecondInt',4)
]
]
)['<Joiners>ParametersJoiner'].insert()
#Definition the AttestedStr
SYS._attest(
[
'MyModulizer is '+SYS._str(
MyModulizer,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
),
'hdf5 file is : '+MyModulizer.hdfview()
]
)
#Close
MyModulizer.close()
# make again
print("Now we reset")
MyBuilder.WatchMakeWithMakerBool = False
# Print
print("After the reset MyBuilder is ")
SYS._print(MyBuilder, **{"RepresentingKeyStrsList": ["MakingMyFloat", "MadeMyInt"]})
# make again
MyBuilder.make(7.0)
# Print
print("After the third make, MyBuilder is ")
SYS._print(MyBuilder, **{"RepresentingKeyStrsList": ["MakingMyFloat", "MadeMyInt"]})
# Definition the AttestedStr
SYS._attest(
[
"BuilderClass.WatchMakeWithMakerBool is " + str(BuilderClass.WatchMakeWithMakerBool),
"BuilderClass.setResetBoolWithMaker_ is " + str(BuilderClass.setResetBoolWithMaker_),
"BuilderClass.make is " + str(BuilderClass.make),
"MyBuilder is "
+ SYS._str(
MyBuilder, **{"RepresentingAlineaIsBool": False, "RepresentingKeyStrsList": ["MakingMyFloat", "MadeMyInt"]}
),
]
)
# Print
#ImportModules
import ShareYourSystem as SYS
from ShareYourSystem.Standards.Interfacers import Closer
#Definition of an instance Closer and make it find the current dir
MyCloser=Closer.CloserClass().file('MyFile.txt','w').close()
#Definition the AttestedStr
SYS._attest(
[
'MyCloser is '+SYS._str(
MyCloser,
**{
'RepresentingAlineaIsBool':False
}
)
]
)
#Print
}
),
(
'<Output>ImageMultiplier/update',
{
'LiargVariablesList':[
[
('MultiplyingFirstInt',1),
('MultiplyingSecondInt',1),
]
]
}
)
]).modulize()
#Definition the AttestedStr
SYS._attest(
[
'MyModulizer is '+SYS._str(
MyModulizer,
**{
'RepresentingBaseKeyStrsListBool':False,
'RepresentingAlineaIsBool':False
}
)
]
)
#Print
View the <NameStr> concept on <a href="'''+SYS.OuvatonUrlStr+'''/slides/<NameStr>.php" target="_blank">Ouvaton</a>
</small>
'''
GuidingClassMarkdownTextStr='''
<!--
FrozenIsBool False
-->
##More Descriptions at the level of the class
Special attributes of the <NameStr>Class are :
'''
GuidingClassCodeTextStr='''
#FrozenIsBool False
#ImportModules
import ShareYourSystem as SYS
from <ParentModuleStr> import <NameStr>
#Definition the AttestedStr
SYS._attest(
[
'DefaultAttributeItemTuplesList is '+SYS._str(
<NameStr>.<NameStr>Class.DefaultAttributeItemTuplesList,
**{'RepresentingAlineaIsBool':False}
)
]
)
