})
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}
		)
	]
)