def mapPoint(self): #debug self.debug( [ 'We map point here', 'PointMapVariable is ', SYS._str(self.PointMapVariable) ] ) #map map( lambda __ElementVariable: self.point( *__ElementVariable ) if type(__ElementVariable) in [list,tuple] else self.point( __ElementVariable ), self.PointMapVariable if type( self.PointMapVariable )==list else self.PointMapVariable.items() )
def getDebuggedStrWithPrintVariable(_PrintVariable): #Type Type=type(_PrintVariable) #Debug ''' print('l 62 Debugger') print('Type is ',Type) print('SYS.StrTypesList is ',SYS.StrTypesList) print('') ''' #set the DebuggedStr with the _PrintVariable if type(_PrintVariable) in SYS.StrTypesList: return _PrintVariable elif type(_PrintVariable)==tuple: #Check for an end if len(_PrintVariable)>3: DebuggedEndStr=_PrintVariable[3] else: DebuggedEndStr="" #join DebuggedStr='\n'.join( map( lambda __KeyStr: _PrintVariable[0]+__KeyStr+DebuggedEndStr+' is '+SYS._str( _PrintVariable[1][__KeyStr] if type( _PrintVariable[1] ) in [collections.OrderedDict,dict] else getattr( _PrintVariable[1], __KeyStr ) if hasattr(_PrintVariable[1],__KeyStr) else "WARNING : No attribute like this" ,**{ 'RepresentingAlineaIsBool':False }), _PrintVariable[2] ) )+'\n' #return return DebuggedStr elif type(_PrintVariable)==list: return '\n'.join(map(getDebuggedStrWithPrintVariable,_PrintVariable)) else: #return return str(_PrintVariable)
def do_view(self): #debug ''' self.debug( [ 'We view here', ('self.',self,[ 'ViewingQtBool' ]) ] ) ''' #Check if self.ViewingIdStr=="": self.ViewingIdStr=str(self.PrintIdInt) #debug self.debug( [ "id(self) is ", str(id(self)), ('self.',self,['ViewingIdStr']), 'SYS.IdDict["+self.ViewingIdStr+"]', SYS._str(SYS.IdDict[int(self.ViewingIdStr)]), #SYS._str(SYS.IdDict[id(self)]), ('self.',self,[ 'ViewingXVariable', 'ViewingYVariable' ]) ] ) #set self.ViewedTagStr=self.StructureTagStr.replace('*','') #/####################/# # Now we view each Axe # #map map( lambda __AxeStr: self.viewAxe(__AxeStr), [ 'X', 'Y' ] ) """
def do_text(self): #Init self.TextedConsoleStr="" #Check if hasattr(self,'hdfview'): #Add self.TextedConsoleStr+="Associated Hdf file :\n" self.TextedConsoleStr+=self.ViewedPointDeriveControllerVariable.hdfview( ).HdformatedConsoleStr #Check if self.ViewedPointDeriveControllerVariable.PymongoneDatabaseVariable!=None: #Check if self.TextingConditionVariable==None: self.TextingConditionVariable={} #map self.TextedCollectionStrsList=map( lambda __CollectionTuple: __CollectionTuple[0]+' : \n'+SYS._str( list( __CollectionTuple[1].find( self.TextingConditionVariable[__CollectionTuple[0]] if __CollectionTuple[0] in self.TextingConditionVariable else {}, self.TextingQueryVariable[__CollectionTuple[0]] if __CollectionTuple[0] in self.TextingQueryVariable else {} ) ) ), self.ViewedPointDeriveControllerVariable.PymongoneDatabaseVariable.__dict__.items() ) self.TextedConsoleStr+="Associated Mongo db :\n" self.TextedConsoleStr='\n'.join(self.TextedCollectionStrsList)
#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
def mimic_set(self): #Check if self.SettingKeyVariable in [ FigurePlotKeyStr, FigureScatterKeyStr, FigureBarKeyStr ]: #debug ''' self.debug( [ 'before plot', ('self.',self,[ #'ViewDeriveControllerVariable', 'SettingValueVariable' ]) ] ) ''' #init FigurePlotArgumentDict=Setter.ArgumentDict( self.SettingValueVariable, self.ViewDeriveControllerVariable ) #debug ''' self.debug( [ 'We plot here', 'FigurePlotArgumentDict is', SYS._str(FigurePlotArgumentDict) ] ) ''' #plot self.FigureCartoonVariablesList.append( self.FiguredAxesVariable.plot( *FigurePlotArgumentDict['LiargVariablesList'], **FigurePlotArgumentDict['KwargVariablesDict'] )[0] ) #debug ''' self.debug( [ ('self.',self,['FigureCartoonVariablesList']), #str(self.FigureCartoonVariablesList[0][0]), ] ) ''' #return return {'HookingIsBool':False} elif self.SettingKeyVariable==FigureAxesKeyStr: #debug ''' self.debug( [ 'before axes', ('self.',self,[ #'ViewDeriveControllerVariable', 'FiguredAxesVariable' ]) ] ) ''' #map ArgumentTuplesList=map( lambda __ItemTuple: ( __ItemTuple[0], Setter.ArgumentDict( __ItemTuple[1], self.ViewDeriveControllerVariable ) ), SYS.SetList( self.SettingValueVariable ) ) #/#################/# # Special case for the legend # #dict ArgumentDict=dict(ArgumentTuplesList) if 'legend' in ArgumentDict: """ #Check if '#kwarg' not in ArgumentDict['legend']: ArgumentDict['legend']['#kwarg']={} #add ArgumentDict['legend']['#kwarg']['handles']=SYS.flat( map( lambda __Figurer: __Figurer.FigureCartoonVariablesList, self.TeamDict['Plots'].ManagementDict.values() ) ) """ #legend self.FiguredAxesVariable.legend() #link #ArgumentTuplesList[SYS.unzip(ArgumentTuplesList,[0]).index('legend')]=( # 'legend', # ArgumentDict['legend'] #) #remove del ArgumentTuplesList[SYS.unzip(ArgumentTuplesList,[0]).index('legend')] #debug self.debug( [ 'We axe here', 'ArgumentTuplesList is ', SYS._str(ArgumentTuplesList) ] ) #map map( lambda __ArgumentTuple: getattr( self.FiguredAxesVariable, __ArgumentTuple[0] )() if len(__ArgumentTuple[1]['LiargVariablesList'] )==0 and __ArgumentTuple[1]['KwargVariablesDict']==None else( getattr( self.FiguredAxesVariable, __ArgumentTuple[0], **__ArgumentTuple[1]['KwargVariablesDict'] )() if len(__ArgumentTuple[1]['LiargVariablesList'] )==0 else( getattr( self.FiguredAxesVariable, __ArgumentTuple[0] )( *__ArgumentTuple[1]['LiargVariablesList'], **__ArgumentTuple[1]['KwargVariablesDict'] ) if __ArgumentTuple[1]['KwargVariablesDict']!=None else getattr( self.FiguredAxesVariable, __ArgumentTuple[0] )( *__ArgumentTuple[1]['LiargVariablesList'] ) ) ), ArgumentTuplesList ) #return return {'HookingIsBool':False} elif type(self.SettingKeyVariable)==str and self.SettingKeyVariable.startswith( FigureMpld3KeyStr): #deprefix ToolTipKeyStr=SYS.deprefix( self.SettingKeyVariable, FigureMpld3KeyStr ) #debug ''' self.debug( [ 'before plugins', ('self.',self,['ViewDeriveControllerVariable']) ] ) ''' #init FigurePluginArgumentDict=Setter.ArgumentDict( self.SettingValueVariable, self.ViewDeriveControllerVariable ) #debug ''' self.debug( [ 'We plugin here', 'FigurePluginArgumentDict is ', SYS._str(FigurePluginArgumentDict) ] ) ''' #plugin from mpld3 import plugins self.FigureTooltipVariablesList=map( lambda __FigureCartoonVariable: getattr( plugins, ToolTipKeyStr )( *[ __FigureCartoonVariable ]+FigurePluginArgumentDict['LiargVariablesList'], **FigurePluginArgumentDict['KwargVariablesDict'] ), self.FigureCartoonVariablesList ) #debug ''' self.debug( [ ('self.',self,['FigureTooltipVariablesList']) ] ) ''' #connect map( lambda __FigureTooltipVariable: plugins.connect( self.FigurePyplotVariable, __FigureTooltipVariable ), self.FigureTooltipVariablesList ) #return return {'HookingIsBool':False} #call the base method BaseClass.set(self)
#ImportModules import ShareYourSystem as SYS #Definition of a Packager instance and module MyPackager=SYS.PackagerClass( ).package( 'ShareYourSystem.Standards.Interfacers.Printer' ) #Definition the AttestedStr print('MyPackager'+SYS._str(MyPackager))
#IntegratingStepsInt 20, #IntegratingInitFloatsArray np.array([0.,0.1]), #IntegratingMoniterVariableIndexIntsArray np.array([0,1]), #IntegratingTimeDelayVariable 10, **{'EuleringJacMethodStr':"euler_leak"} ) #Definition the AttestedStr SYS._attest( [ 'MyIntegrater is '+SYS._str( MyIntegrater, **{ 'RepresentingBaseKeyStrsListBool':False, 'RepresentingAlineaIsBool':False } ), ] ) #plot from matplotlib import pyplot pyplot.plot(MyIntegrater['<StateMoniters>VariableMoniter'].MoniteredTotalVariablesArray.T) pyplot.show() #Print
('MyIntsList','MyIntsList',SYS.tables.Int64Col(shape=3)) ] } ).model( ) #Build a structure with a database SYS.mapSet( MyModeler.ModeledHdfTable, [ ('row.__setitem__',{'#liarg':('MyStr',"hello")}), ('row.append',{'#liarg':None}), ('row.__setitem__',{'#liarg':('MyStr',"bonjour")}), ('row.__setitem__',{'#liarg':('MyIntsList',[4,5,6])}), ('row.append',{'#liarg':None}), ('flush',{'#liarg':None}) ] ) #Definition the AttestedStr print('MyModeler is ') SYS._print(MyModeler) #view print('hdf5 file is : \n'+SYS._str(MyModeler.hdfview())) #close MyModeler.file(_ModeStr='c')
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
} ).model( ).mapSet( { 'MyInt':0, 'MyStr':"hello", 'MyIntsList':[2,4,1] } ).insert( ).mapSet( { 'MyInt':5, 'MyStr':"bonjour", 'MyIntsList':[0,0,0] } ).insert( ).retrieve( #RetrievingIndexIntsList [0,0] ) #Definition the AttestedStr print('MyRetriever is ') SYS._print(MyRetriever) #print print('mongo db is : \n'+SYS._str(MyRetriever.pymongoview())) #Print MyRetriever.file(_ModeStr='c')
def do_point(self): #debug ''' self.debug( [ 'we point here', ('self.',self,[ 'PointingToGetVariable', 'PointingToSetKeyVariable' ]) ] ) ''' #Check if self.PointingToGetVariable!=None: #/###################/# # First point TO like a classic set # #debug self.debug( [ 'First we get the target', ('self.',self,['PointingToGetVariable']) ] ) #get PointedToVariable=self[ self.PointingToGetVariable ] #debug ''' self.debug( [ 'PointedToVariable is '+SYS._str( PointedToVariable ), 'If it is None, maybe we have to parent first' ] ) ''' #Check """ if PointedToVariable==None: #parent self['?^'] #debug self.debug( [ 'We have parented', ('self.',self,['ParentedTotalPathStr']), 'So we can get again' ] ) #get PointedToVariable=self[ self.PointingToGetVariable ] """ #debug ''' self.debug( [ 'PointedToVariable is '+SYS._str( PointedToVariable ), 'Now we check the set key str' ] ) ''' #/####################/# # Check for the SetKeyVariable # #Check if self.PointingToSetKeyVariable in [None,""]: #debug ''' self.debug( [ "self.PointingToSetKeyVariable in [None,""]...", "so we use the PointingGetVariable to name the pointer" ] ) ''' #str PointedToSetKeyVariable=str( self.PointingToGetVariable ).replace('/','_') #debug self.debug( [ 'PointedToSetKeyVariable is '+PointedToSetKeyVariable ] ) #Check if self.PointingManagementBool: #debug self.debug( [ 'We put that in the Management dict' ] ) #add PointedToSetKeyVariable=Manager.ManagementChildPrefixStr+PointedToSetKeyVariable else: #set direct PointedToSetKeyVariable=self.PointingToSetKeyVariable #debug ''' self.debug( 'PointedToSetKeyVariable is '+SYS._str( PointedToSetKeyVariable ) ) ''' #Check if type(PointedToSetKeyVariable)==str and PointedToSetKeyVariable.endswith( Pather.PathPrefixStr)==False: #debug ''' self.debug('It is a direct path') ''' if self.PointingEncapsulationBool==False: #set self.set( PointedToSetKeyVariable, PointedToVariable ) else: pass else: #debug ''' self.debug( [ 'It is an encapsulate path', 'PointedToSetKeyVariable is ', str(PointedToSetKeyVariable), 'Check if it is with a str or a variable' ] ) ''' #/###############/# # Case where it is just a default encapsulator # #Check if type(PointedToSetKeyVariable)==str: #previous PointedPreviousSetTagStr,PointedKeyStr=SYS.previous( PointedToSetKeyVariable ) #debug self.debug( [ 'PointedPreviousSetTagStr is ', PointedPreviousSetTagStr, 'PointedKeyStr is ', PointedKeyStr ] ) #Check if self.PointingManagementBool: #debug self.debug( [ 'We put that in the Management dict' ] ) #add PointedPreviousSetTagStr=Manager.ManagementChildPrefixStr+PointedPreviousSetTagStr #get PointedGettedValueVariable=self[ PointedPreviousSetTagStr ] #Check if PointedKeyStr!="": #debug self.debug( 'We just set normally' ) #point PointedGettedValueVariable.set( PointedKeyStr, PointedToVariable ) else: #debug self.debug( 'We set the PointToVariable and PointFromVariable' ) #point PointedGettedValueVariable.set( 'PointToVariable', PointedToVariable ) #point PointedGettedValueVariable.set( 'PointFromVariable', self ) #debug ''' self.debug( [ 'After getting', ('locals()["',locals(),[ 'PointedToVariable', ],'] ) ] ) ''' #/###################/# # Maybe do a back point # #Check if self.PointingBackBool: #debug ''' self.debug( [ 'We point back', ('self.',self,['PointingBackSetKeyVariable']) ] ) ''' #Check if self.PointingBackSetKeyVariable==None: #debug ''' self.debug( 'PointedToSetKeyVariable is '+str(PointedToSetKeyVariable) ) ''' #/###################/# # Case where the PointedToSetKeyVariable is derived from a pathsetstr # #split PointedKeyStrsList=PointedToSetKeyVariable.split('_') if len(PointedKeyStrsList)>1: #remove the last PointedKeyStrsList=PointedKeyStrsList[1:] #reverse PointedKeyStrsList.reverse() #join PointedBackSetKeyVariable='_'.join(PointedKeyStrsList) #/###################/# # else just take the id and put a prefix # else: #set default PointedBackSetKeyVariable=str(self.PrintIdInt) #add PointedBackSetKeyVariable=PointBackPrefixStr+PointedBackSetKeyVariable+self.NameStr else: #just alias PointedBackSetKeyVariable=self.PointingBackSetKeyVariable #debug self.debug( [ 'we set the back', 'PointedBackSetKeyVariable is '+SYS._str( PointedBackSetKeyVariable ), 'PointedToVariable is '+SYS._str( PointedToVariable ) ] ) #set PointedToVariable.point( self, PointedBackSetKeyVariable, _BackBool=False ) #alias self.PointedToVariable=PointedToVariable
#ImportModules import ShareYourSystem as SYS from ShareYourSystem.Standards.Modelers import Explorer import tables #Definition a structure with a db ThingsExplorer=Explorer.ExplorerClass() #Definition the AttestedStr SYS._attest( [ 'ThingsExplorer is '+SYS._str( ThingsExplorer, **{ 'RepresentingBaseKeyStrsListBool':False, 'RepresentingAlineaIsBool':False } ), 'hdf5 file is : '+ThingsExplorer.hdfview().hdfclose().HdformatedConsoleStr ] ) #Print
#Definition a Nbconverter MyNbconverter=Nbconverter.NbconverterClass().package( 'ShareYourSystem.Standards.Objects.Concluder' ).scriptbook( **{ 'GuidingBookStr':'Doc' } ).notebook( 'Presentation.ipynb' ).nbconvert( 'Readme.md', 'Slide' ) #Definition the AttestedStr SYS._attest( [ 'MyNbconverter is '+SYS._str( MyNbconverter, **{ 'RepresentingBaseKeyStrsListBool':False, 'RepresentingAlineaIsBool':False } ) ] ) #Print
MyDistinguisher.distinguish( "Distinguishers",[ [('MyStr',"hello")], [('MyInt',0)] ]) #distinguish through setting MyDistinguisher.__setitem__( "Dis_<Distinguishers>", [ [('MyOtherStr',"bonjour")], [('MyOtherInt',1)] ] ) #Definition the AttestedStr SYS._attest( [ 'MyDistinguisher is '+SYS._str( MyDistinguisher, **{ 'RepresentingBaseKeyStrsListBool':False, 'RepresentingAlineaIsBool':False } ) ] ) #Print
'MyIntsList' ] } ).model( ).mapSet( { 'MyStr':"hello", 'MyIntsList':[2,4,1] } ).insert( ).mapSet( { 'MyStr':"bonjour", 'MyIntsList':[0,0,1] } ).insert( ) #print print('MyInserter is ') SYS._print(MyInserter) #view print('hdf5 file is : \n'+SYS._str(MyInserter.hdfview())) #close MyInserter.file(_ModeStr='c')
#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
#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
#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
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
# 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
def pyplotChart(self): #debug ''' self.debug( [ 'Chart level.' ] ) ''' #/#################/# # Determine the parent # #set self.PyplotedParentPanelDerivePyploterVariable=self.ParentDeriveTeamerVariable.ParentDeriveTeamerVariable #debug ''' self.debug( [ 'self.PyplotedParentPanelDerivePyploterVariable.PyplotedParentSingularStr is ', self.PyplotedParentPanelDerivePyploterVariable.PyplotedParentSingularStr, 'Check now who are the parents' ] ) ''' #Check if self.PyplotedParentPanelDerivePyploterVariable.ParentDeriveTeamerVariable!=None: #debug self.debug( [ 'Ok there is a parent parent for this Chart' ] ) #alias PyplotedParentFigureDerivePyploterVariable=self.PyplotedParentPanelDerivePyploterVariable.ParentDeriveTeamerVariable.ParentDeriveTeamerVariable if PyplotedParentFigureDerivePyploterVariable!=None: #set self.PyplotedParentFigureDerivePyploterVariable=PyplotedParentFigureDerivePyploterVariable #debug self.debug( [ 'Yes the panel parent parent exists' ] ) else: #debug self.debug( [ 'Nope the parent parent not exist so direct set figure with panel parent' ] ) #set self.PyplotedParentFigureDerivePyploterVariable=self.PyplotedParentPanelDerivePyploterVariable else: #set self.PyplotedParentFigureDerivePyploterVariable=self #debug self.debug( [ 'Ok for this Chart, we have determined the panel and figure parent', #('self.',self,[ # 'PyplotedParentFigureDerivePyploterVariable' #]) ] ) #/#################/# # First shift in the grid # #Check if self.ManagementIndexInt>0: #debug ''' self.debug( [ 'first we shift', 'self.PyplotedParentPanelDerivePyploterVariable.PyplotedCursorIntsList is ', str(self.PyplotedParentPanelDerivePyploterVariable.PyplotedCursorIntsList), ('self.',self,['PyplotingShapeIntsTuple','PyplotingShiftIntsTuple']) ] ) ''' #get PreviousChartPyploter=self.ParentDeriveTeamerVariable.ManagementDict.getValue( self.ManagementIndexInt-1 ) #debug self.debug( [ 'We have getted the PreviousChartPyploter', 'PreviousChartPyploter is ', SYS._str(PreviousChartPyploter) ] ) #shift if self.PyplotingShiftIntsTuple[0]>0: self.PyplotedParentPanelDerivePyploterVariable.PyplotedCursorIntsList[0 ]+=self.PyplotingShiftIntsTuple[0]+PreviousChartPyploter.PyplotingShapeIntsTuple[0] if self.PyplotingShiftIntsTuple[1]>0: self.PyplotedParentPanelDerivePyploterVariable.PyplotedCursorIntsList[1 ]+=self.PyplotingShiftIntsTuple[1]+PreviousChartPyploter.PyplotingShapeIntsTuple[1] #debug ''' self.debug( [ 'Ok we have shifted', 'now we link with the fig', ('self.PyplotedParentPanelDerivePyploterVariable.',self.PyplotedParentPanelDerivePyploterVariable, ['PyplotedCursorIntsList']), ] ) ''' #set if self.PyplotedParentPanelDerivePyploterVariable!=None: self.PyplotedAnchorIntsList=copy.copy( self.PyplotedParentPanelDerivePyploterVariable.PyplotedCursorIntsList ) #/#################/# # init # #debug ''' self.debug( [ 'Ok we set an axes here', ('self.',self,[ 'PyplotingGridIntsTuple', 'PyplotedAnchorIntsList', 'PyplotingShapeIntsTuple' ]), '' ] ) ''' #init from matplotlib import pyplot self.PyplotedAxesVariable=pyplot.subplot2grid( self.PyplotedParentFigureDerivePyploterVariable.PyplotingGridIntsTuple, self.PyplotedAnchorIntsList, rowspan=self.PyplotingShapeIntsTuple[0], colspan=self.PyplotingShapeIntsTuple[1] ) #debug ''' self.debug( [ 'Ok we have initiated the axes', ('self.',self,['PyplotedAxesVariable']) ] ) ''' #/#################/# # link to the fig # #link self.PyplotedAxesVariable._figure=self.PyplotedFigureVariable #debug '''
} ), ( '<Output>ImageMultiplier/update', { 'LiargVariablesList':[ [ ('MultiplyingFirstInt',1), ('MultiplyingSecondInt',1), ] ] } ) ]).modulize() #Definition the AttestedStr SYS._attest( [ 'MyModulizer is '+SYS._str( MyModulizer, **{ 'RepresentingBaseKeyStrsListBool':False, 'RepresentingAlineaIsBool':False } ) ] ) #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
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
'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'].)
).command( '/-Models/|Result', [ '#call:insert', ('setSwitch',['insert']) ] ).mapSet( [ ('SumingFirstInt',3), ('SumingSecondInt',5) ] ).sum( ).command( '/-Models/|Result', '#call:insert' ) #/######################/# # Print # #print print('MySumer is ') SYS._print(MySumer) #view print('hdf5 file is : \n'+SYS._str(MySumer.hdfview())) #close MySumer.file(_ModeStr='c')
"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
#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
#Definition MyController=SYS.ControllerClass( **{ 'FolderingPathStr':SYS.Tabularer.LocalFolderPathStr, 'ControllingModelClassVariable':SYS.TabularerClass } ).set( '/-Models/|Things', { 'ModelingDescriptionTuplesList': [ #GetStr #ColumnStr #Col ('MyInt','MyInt',tables.Int64Col()), ('MyStr','MyStr',tables.StringCol(10)), ('MyIntsList','MyIntsList',tables.Int64Col(shape=3)) ] } ) #Definition the AttestedStr print('MyController is ') SYS._print(MyController) #view print('hdf5 file is : \n'+SYS._str(MyController.hdfview())) #close MyController.file(_ModeStr='c')
#Definition MyController=SYS.ControllerClass( **{ 'FolderingPathStr':SYS.Tabler.LocalFolderPathStr, 'ControllingModelClassVariable':SYS.TabularerClass } ).get( '/-Models/|Things' ) #Build a structure with a database SYS.set( MyController['/-Models/|Things'].ModeledMongoCollection, [ ('remove',{}), ('insert',{'MyStr':"hello"}) ] ) #print print('mongo db is : \n'+SYS._str(MyController.pymongoview())) #print print('MyController is ') SYS._print(MyController) #kill MyController.process(_ActionStr='kill')