def mimic_set(self):
""" """
#debug
'''
self.debug(('self.',self,['SettingKeyVariable','SettingValueVariable']))
'''
#Check
if type(self.SettingKeyVariable
)==str:
#Check
if self.SettingKeyVariable.startswith(AttributionInstancePrefixStr):
#debug
'''
self.debug('We are going to attribute to the instance')
'''
#Path
self.attribute(
SYS.deprefix(
self.SettingKeyVariable,
AttributionInstancePrefixStr
),
self.SettingValueVariable,
_InstanceBool=True,
_ClassBool=False
)
#Stop the setting
return {'HookingIsBool':False}
elif self.SettingKeyVariable.startswith(AttributionClassPrefixStr):
#debug
'''
self.debug('We are going to attribute to the class')
'''
#Path
self.attribute(
SYS.deprefix(
self.SettingKeyVariable,
AttributionClassPrefixStr
),
self.SettingValueVariable,
_InstanceBool=False,
_ClassBool=True,
)
#Stop the setting
return {'HookingIsBool':False}
#Set and return
return BaseClass.set(self)
def mimic_get(self):
#Check
if type(self.GettingKeyVariable)==str:
#Check
if self.GettingKeyVariable.startswith(ConnectGetSetPrefixStr):
#debug
'''
self.debug(
[
'We get connect here',
('self.',self,['GettingKeyVariable'])
]
)
'''
#connect
self.connect(
SYS.deprefix(
self.GettingKeyVariable,
ConnectGetSetPrefixStr
)
)
#return
return {'HookingIsBool':False}
#set
BaseClass.get(self)
def mimic_set(self):
#Definition
OutputDict={'HookingIsBool':True}
#debug
'''
self.debug(('self.',self,['SettingKeyVariable']))
'''
#Check
if type(
self.SettingKeyVariable
)==str and self.SettingKeyVariable.startswith(TeamChildPrefixStr):
#debug
'''
self.debug('We team here')
'''
#team
self.team(
SYS.deprefix(
self.SettingKeyVariable,
TeamChildPrefixStr
),
self.SettingValueVariable
)
#Stop the setting
OutputDict["HookingIsBool"]=False
#Call the parent get method
if OutputDict['HookingIsBool']:
return BaseClass.set(self)
def mimic_get(self):
#get
if type(self.GettingKeyVariable
)==str:
#Check
if self.GettingKeyVariable.startswith(AttributionInstancePrefixStr):
#debug
'''
self.debug('We are going to get into the instance')
'''
#get
self.GettedValueVariable=self.__dict__[
SYS.deprefix(
self.GettingKeyVariable,
AttributionInstancePrefixStr
)
]
#Stop the setting
return {'HookingIsBool':False}
elif self.GettingKeyVariable.startswith(AttributionClassPrefixStr):
#debug
'''
self.debug('We are going to get from the class')
'''
#Path
self.GettedValueVariable=self.__class__.__dict__[
SYS.deprefix(
self.GettingKeyVariable,
AttributionClassPrefixStr
)
]
#Stop the setting
return {'HookingIsBool':False}
#return
return BaseClass.get(self)
def mimic_get(self):
#Definition
OutputDict={'HookingIsBool':True}
#debug
'''
self.debug(('self.',self,['GettingKeyVariable']))
'''
#Check
if self.GettingKeyVariable==TeamParentManagerPrefixStr+'Manager':
#alias
self.GettedValueVariable=self.ManagementPointDeriveManager
#Stop the setting
OutputDict["HookingIsBool"]=False
#Check
if self.GettingKeyVariable==Manager.ManagementParentTeamerPrefixStr+'Teamer':
#alias
if self.ManagementPointDeriveManager!=None:
self.GettedValueVariable=self.ManagementPointDeriveManager.TeamPointDeriveTeamer
else:
self.GettedValueVariable=None
#Stop the setting
OutputDict["HookingIsBool"]=False
#Check
elif type(
self.GettingKeyVariable
)==str and self.GettingKeyVariable.startswith(TeamChildPrefixStr):
#debug
'''
self.debug('We team here')
'''
#team
self.GettedValueVariable=self.team(
SYS.deprefix(
self.GettingKeyVariable,
TeamChildPrefixStr
)
).TeamedValueVariable
#Stop the setting
OutputDict["HookingIsBool"]=False
#Call the parent get method
if OutputDict['HookingIsBool']:
return BaseClass.get(self)
def mimic_get(self):
# Check
if type(self.GettingKeyVariable) == str:
# Check
if self.GettingKeyVariable.startswith(ProcessPrefixStr):
# deprefix
GetProcessBashStr = SYS.deprefix(self.GettingKeyVariable, ProcessPrefixStr)
# process
self.process(GetProcessBashStr)
# set
self.GettedValueVariable = self.ProcessedBashStr
# stop
return {"HookingIsBool": False}
# Cal the base method
BaseClass.get(self)
def do_get(self):
""" """
#debug
'''
self.debug(
[
("self.",self,[
'GettingKeyVariable',
'NameStr',
'GettingItemBool'
]
)
]
)
'''
#itemize first
if self.GettingItemBool:
#debug
'''
self.debug('first we itemize')
'''
#Check
if self.GettingKeyVariable==GetMapStr:
#set
self.ItemizingMapGetVariable='GettedValueVariable'
#itemize
self.itemize(
self.GettingKeyVariable
)
#Check
#if self.GettingKeyVariable==GetMapStr:
#
# #set
# self.GettingItemBool=False
else:
#set
self.ItemizedValueMethod=None
#set
#self.GettingItemBool=True
#/############################
# Case of a method get
#
#debug
'''
self.debug(
('self.',self,['ItemizedValueMethod'])
)
'''
#Check
if self.ItemizedValueMethod!=None:
#debug
'''
self.debug(
[
'This is a method get',
('self.',self,[
'ItemizedValueMethod',
'ItemizingMapGetVariable'
]
)
]
)
'''
#alias
self.GettedValueVariable=self.ItemizedValueMethod
#Stop the getting
return {"HookingIsBool":False}
#/############################
# Case of a GetClass get
#
#Check
if type(self.GettingKeyVariable)==GetClass:
#Check
if self.GettingKeyVariable.SelfVariable==None:
self.GettingKeyVariable.SelfVariable=self
#call
self.GettedValueVariable=self.GettingKeyVariable()
#Stop the getting
return {"HookingIsBool":False}
#/############################
# Cases of a key str get
#
#Check
if type(self.GettingKeyVariable) in [str,unicode]:
#debug
'''
self.debug(
[
'This is a non method get',
('self.',self,[
'GettingKeyVariable',
'GettingNewBool'
])
]
)
'''
'''
#/############################
# Case of a delete in the instance __dict__
#
if self.GettingKeyVariable.startswith(GetDeletePrefixStr)
#delete
del self.__dict__[
SYS.deprefix(
self.GettingKeyVariable,
GetDeletePrefixStr
)
]
#Stop the getting
return {"HookingIsBool":False}
'''
#/############################
# Case of a direct str get
#
if self.GettingKeyVariable.startswith(GetDirectPrefixStr):
#debug
'''
self.debug('This is a direct get of a str variable')
'''
#set
self.GettedValueVariable=SYS.deprefix(
self.GettingKeyVariable,
GetDirectPrefixStr
)
#Stop the getting
return {"HookingIsBool":False}
#/############################
# Case of a call str get
#
if self.GettingKeyVariable.startswith(GetCallPrefixStr):
#get
GettedMethod=self[
SYS.deprefix(
self.GettingKeyVariable,
GetCallPrefixStr
)
]
#debug
'''
self.debug(
[
'This is a call get of a str variable',
'GettedMethod is '+SYS._str(GettedMethod)
]
)
'''
if type(GettedMethod)==types.MethodType:
#set
self.GettedValueVariable=GettedMethod()
else:
#set
self.GettedValueVariable=GettedMethod(self)
#Stop the getting
return {"HookingIsBool":False}
#/############################
# Case of a #id: get of an instance thanks to its id
#
elif self.GettingKeyVariable.startswith(GetIdPrefixStr):
#deprefix
GettedKeyStr=SYS.deprefix(
self.GettingKeyVariable,
GetIdPrefixStr
)
#debug
'''
self.debug(
[
'This is a id get ',
'GettedKeyStr is '+GettedKeyStr
]
)
'''
#IdDict
self.GettedValueVariable=SYS.IdDict[
int(GettedKeyStr)
]
#Stop the getting
return {"HookingIsBool":False}
#/############################
# Case of a #get: str get
#
elif self.GettingKeyVariable.startswith(GetUndirectPrefixStr):
#deprefix
GettedKeyStr=SYS.deprefix(
self.GettingKeyVariable,
GetUndirectPrefixStr
)
#debug
'''
self.debug(
[
'This is a undirect of a str variable',
'GettedKeyStr is '+GettedKeyStr
]
)
'''
#Check
if GetUndirectPrefixStr in GettedKeyStr:
#split
GettedKeyStrsList=GettedKeyStr.split(GetUndirectPrefixStr)
#define
GettedRecursiveKeyStr=''.join(GettedKeyStrsList[:-1])+self[GettedKeyStrsList[-1]]
#debug
'''
self.debug(
[
'This is a recursive undirect get',
'GettedRecursiveKeyStr is '+GettedRecursiveKeyStr
]
)
'''
#set
self.GettedValueVariable=self[
GetUndirectPrefixStr+GettedRecursiveKeyStr
]
else:
#debug
'''
self.debug(
'This is one level undirect get'
)
'''
#set
self.GettedValueVariable=self[
self[GettedKeyStr]
]
#Stop the getting
return {"HookingIsBool":False}
#/############################
# Case of a get in the instance __dict__
#
#Get safely the Value
elif self.GettingKeyVariable in self.__dict__:
#debug
'''
self.debug(
[
'self.GettingKeyVariable exists in the __dict__',
self.GettingKeyVariable
]
)
'''
#__getitem__ in the __dict__
self.GettedValueVariable=self.__dict__[
self.GettingKeyVariable
]
#Check
if type(self.GettedValueVariable)==GetClass:
#debug
'''
self.debug(
[
'Actually the getted value is a GetClass'
]
)
'''
#set
self.GettedValueVariable.SelfVariable=self
#call
self.GettedValueVariable=self.GettedValueVariable()
#debug
'''
self.debug(
[
'This is a Spe in Instance',
('self.',self,['GettedValueVariable'])
]
)
'''
#Stop the getting
return {"HookingIsBool":False}
#/############################
# Case of the __class__ get
#
#Check
elif self.GettingKeyVariable=='__class__':
#set
self.GettedValueVariable=self.__class__
#Stop the getting
return {"HookingIsBool":False}
#/############################
# Case of a get in the instance __dict__
#
#Check
elif self.GettingKeyVariable in self.__class__.__dict__:
#debug
'''
self.debug(
[
'this is in a class __dict__',
('self.',self,['GettingKeyVariable'])
]
)
'''
#get
GettedClassValueVariable=self.__class__.__dict__[
self.GettingKeyVariable
]
#/############################
# Case of a get of a property
#
if type(GettedClassValueVariable)==property:
#get by the reactive getattr
self.GettedValueVariable=getattr(self,self.GettingKeyVariable)
else:
#__getitem__ in the __class__
self.GettedValueVariable=GettedClassValueVariable
#debug
'''
self.debug(
[
'This is in the __class__',
('self.',self,['GettedValueVariable'])
]
)
'''
#Stop the getting
return {"HookingIsBool":False}
elif self.GettingNewBool:
#debug
'''
self.debug(
[
'we are going to set a default value here',
('self.',self,['GettingKeyVariable'])
]
)
'''
#get
GettedValueType=SYS.getTypeClassWithTypeStr(
SYS.getTypeStrWithKeyStr(
self.GettingKeyVariable)
)
#debug
'''
self.debug(
[
'GettedValueType is '+str(GettedValueType),
('self.',self,['GettingKeyVariable'])
]
)
'''
#Check
if callable(GettedValueType):
#debug
self.debug(
[
'We call here',
'GettedValueType is '+str(GettedValueType),
('self.',self,['GettingKeyVariable'])
]
)
#alias
self.GettedValueVariable=GettedValueType()
#set a default value
self.__setattr__(
self.GettingKeyVariable,
self.GettedValueVariable
)
#add in the SettingValue
try:
self.GettedValueVariable.SetTagStr=self.GettingKeyVariable
self.GettedValueVariable.SetDeriveSetter=self
except:
pass
#Stop the getting
return {"HookingIsBool":False}
#/############################
# Cases of a dict GetVariable get
#
elif hasattr(self.GettingKeyVariable,'items'
) and type(self.GettingKeyVariable)!=type:
#debug
'''
self.debug(
[
'we get or set with an itemizable instance',
('self.',self,['GettingKeyVariable'])
]
)
'''
#Init
GettedReturnBool=False
#Temp
GettedTempGettingKeyVariable=self.GettingKeyVariable
#Check
if GetGrabStr in GettedTempGettingKeyVariable:
#debug
'''
self.debug(
[
'we get with the GetGrabStr'
]
)
'''
#get
self.GettedValueVariable=self[
GettedTempGettingKeyVariable[GetGrabStr]
]
#set
GettedReturnBool=True
elif GetUndirectGrabStr in GettedTempGettingKeyVariable:
#get
GettedKeyStr=GettedTempGettingKeyVariable[GetUndirectGrabStr]
#debug
'''
self.debug(
[
'we get with the GetUndirectGrabStr',
('self.',self,['GettingKeyVariable']),
'GettedKeyStr is '+GettedKeyStr
]
)
'''
#get get
self.GettedValueVariable=self[
self[
GettedKeyStr
]
]
#set
GettedReturnBool=True
#Check
elif GetMapUndirectGrabStr in GettedTempGettingKeyVariable:
#get
GettedLiargVariablesList=GettedTempGettingKeyVariable[
GetMapUndirectGrabStr
]
#debug
'''
self.debug(
[
'we get with the GetMapUndirectGrabStr',
('self.',self,['GettingKeyVariable']),
'GettedLiargVariablesList is '+SYS._str(GettedLiargVariablesList)
]
)
'''
#get
self.GettedValueVariable=self[
SYS.deprefix(
GetMapUndirectGrabStr,
GetUndirectGrabPrefixStr
)
](
*GettedLiargVariablesList
).ItemizedMapValueVariablesList
#set
GettedReturnBool=True
#/##################/#
# Case of a modification
#
#Check
if GetModifyGrabStr in GettedTempGettingKeyVariable:
#debug
'''
self.debug(
'We modify here '
)
'''
#call
#self.GettedValueVariable=GettedTempGettingKeyVariable[
# GetModifyGrabStr
#]()
self.GettedValueVariable=self[
GettedTempGettingKeyVariable[GetModifyGrabStr]
]
if GetSetGrabStr in GettedTempGettingKeyVariable:
#debug
'''
self.debug(
'We set here in the GettedValueVariable'
)
'''
#get
SetVariable=GettedTempGettingKeyVariable[GetSetGrabStr]
#set
self.GettedValueVariable[
SetVariable[0]
]=SetVariable[1]
elif GetMapSetGrabStr in GettedTempGettingKeyVariable:
#debug
'''
self.debug(
'We map a set here in the GettedValueVariable'
)
'''
#get
SetVariable=GettedTempGettingKeyVariable[GetMapSetGrabStr]
#Check
if hasattr(SetVariable,'items'):
SetVariablesList=SetVariable.items()
else:
SetVariablesList=SetVariable
#set
map(
lambda __SetVariable:
self.GettedValueVariable.__setitem__(
__SetVariable[0],
__SetVariable[1]
),
SetVariablesList
)
#Check
if GettedReturnBool:
#Stop the getting
return {"HookingIsBool":False}
#/############################
# Cases of a direct get
#
#elif hasattr(self.GettingKeyVariable,'MroClassesList'):
if type(self.GettingKeyVariable)!=str:
#debug
'''
self.debug('This is a direct get of a non str variable')
'''
#set
self.GettedValueVariable=self.GettingKeyVariable
#Stop the getting
return {"HookingIsBool":False}
#set
self.GettedValueVariable=None
#debug
'''
self.debug(
[
'Not found here so set it to None',
('self.',self,['GettedValueVariable'])
]
)
'''
#Return an output dict
return {"HookingIsBool":True}
def do_set(self):
""" """
#debug
'''
self.debug(
("self.",self,[
'SettingKeyVariable',
'SettingValueVariable'
])
)
'''
#itemize first
if self.SettingItemBool:
#debug
'''
self.debug('first we itemize')
'''
#itemize
self.itemize(
self.SettingKeyVariable
)
else:
#set
self.ItemizedValueMethod=None
#/############################
# Case of a method get
#
#debug
'''
self.debug(
('self.',self,['ItemizedValueMethod'])
)
'''
#Check
if self.ItemizedValueMethod!=None:
#debug
'''
self.debug('we are going to call the method but first get it')
'''
#get
SettedValueMethod=self[self.SettingKeyVariable]
#debug
'''
self.debug('SettedValueMethod is '+str(SettedValueMethod))
'''
#define
try:
#get
SettedLiargVariablesList=SettedValueMethod.im_func.BaseDoClass.Module.getLiargVariablesList(
self.SettingValueVariable
)
'''
self.debug(
'SettedLiargVariablesList is '+str(SettedLiargVariablesList)
)
'''
#get the method and put the value as arguments
SettedValueMethod(*SettedLiargVariablesList)
except:
#debug
'''
self.debug('call the SettedValueMethod with self.SettingValueVariable directly')
'''
#direct
#SettedValueMethod(*self.SettingValueVariable)
SettedValueMethod(self.SettingValueVariable)
#debug
#Stop the setting
return {"HookingIsBool":False}
#/####################/#
# Case of a non method with set with a set key str
#
elif type(self.SettingKeyVariable
)==str:
#/####################/#
# Case of #each: set
#
#Check
if self.SettingKeyVariable.startswith(
SetEachPrefixStr
):
#get
SettedGetVariable=self[
SYS.deprefix(
self.SettingKeyVariable,
SetEachPrefixStr
)
]
#Check
if hasattr(SettedGetVariable,'values'):
SettedGetVariablesList=SettedGetVariable.values()
else:
SettedGetVariablesList=SettedGetVariable
#debug
'''
self.debug(
[
'SettedGetVariablesList is ',
SYS._str(SettedGetVariablesList),
('self.',self,['SettingValueVariable'])
]
)
'''
#map
map(
lambda __SettedGetVariable,__SettedValueVariable:
__SettedGetVariable.set(
*__SettedValueVariable
)
if type(__SettedValueVariable) in [
list,tuple
] and len(__SettedValueVariable)==2
else
__SettedGetVariable['#map@set'](
__SettedValueVariable
),
SettedGetVariablesList,
self.SettingValueVariable
)
#Return stop the setting
return {'HookingIsBool':False}
#/####################/#
# Case of #all: set
#
#Check
elif self.SettingKeyVariable.startswith(
SetAllPrefixStr
):
#get
SettedGetVariable=self[
SYS.deprefix(
self.SettingKeyVariable,
SetAllPrefixStr
)
]
#Check
if hasattr(SettedGetVariable,'values'):
SettedGetVariablesList=SettedGetVariable.values()
else:
SettedGetVariablesList=SettedGetVariable
#debug
'''
self.debug(
[
'SettedGetVariablesList is ',
SYS._str(SettedGetVariablesList),
('self.',self,['SettingValueVariable'])
]
)
'''
#Check
if type(self.SettingValueVariable) in [
list,tuple
] and len(self.SettingValueVariable)==2:
#map
map(
lambda __SettedGetVariable:
__SettedGetVariable.set(
*self.SettingValueVariable
),
SettedGetVariablesList
)
else:
#map
map(
lambda __SettedGetVariable:
__SettedGetVariable['#map@set'](
self.SettingValueVariable
),
SettedGetVariablesList
)
#Return stop the setting
return {'HookingIsBool':False}
#/####################/#
# Case of a set in the __dict__
#
else:
#/####################/#
# Case of an instancing set
#
#Check
if self.SettingTypeBool:
#debug
'''
self.debug(
[
'we check if we have to set a default value here',
('self.',self,[
'SettingKeyVariable',
'SettingValueVariable'
])
]
)
'''
#get
SettedValueType=SYS.getTypeClassWithTypeStr(
SYS.getTypeStrWithKeyStr(
self.SettingKeyVariable)
)
#Check
if SettedValueType!=type(self.SettingValueVariable):
#debug
'''
self.debug(
[
'SettedValueType is '+str(SettedValueType)
]
)
'''
#Check
if SettedValueType!=None.__class__:
#debug
self.debug(
[
'we wrap the setting value',
('self.',self,['SettingValueVariable'])
]
)
#alias
'''
try:
'''
#map set
self.SettingValueVariable=SettedValueType(
)['#map@set'](
self.SettingValueVariable
)
'''
except:
#debug
self.debug(
[
'set failed because the suffix str indicates a different type from the value',
'SettedValueType is '+str(SettedValueType),
'type(self.SettingValueVariable) is '+str(
type(self.SettingValueVariable))
]
)
'''
#debug
'''
self.debug(
[
'we just set in the __dict__',
('self.',self,[
'SettingKeyVariable',
'SettingValueVariable'
])
]
)
'''
#map
'''
if type(self.SettingKeyVariable)==SYS.MapListClass:
#map
map(
lambda __MappedVariable:
self.__setitem__(
*__MappedVariable
),
self.SettingKeyVariable
)
#Return an output dict
return {"HookingIsBool":False}
else:
'''
#__setitem__ in the __dict__, this is an utility set
self.__dict__[
self.SettingKeyVariable
]=self.SettingValueVariable
#add in the SettingValue
try:
self.SettingValueVariable.SetTagStr=self.SettingKeyVariable
#self.SettingValueVariable.SetDeriveSetter=self
except:
pass
#Return
return {'HookingIsBool':False}
#/####################/#
# Case of a non method with set with a set dict
#
elif hasattr(self.SettingKeyVariable,'items'):
#debug
self.debug(
[
'SettingKeyVariable has items...',
('self.',self,['SettingKeyVariable'])
]
)
try:
#debug
self.debug(
'We set with a SetKeyVariable'
)
#set
self.set(
self.SettingKeyVariable['SetKeyVariable'],
self.SettingValueVariable
)
#delete
del self.SettingKeyVariable['SetKeyVariable']
except:
#debug
self.debug(
'We set with a SetKeyVariable'
)
#set
self.set(
self.SettingKeyVariable['SetKeyVariable'],
SYS.update(
self.SettingKeyVariable,
self.SettingValueVariable
)
)
#delete
del self.SettingKeyVariable['SetKeyVariable']
#Return
return {'HookingIsBool':False}
def mimic_set(self):
#Check
if self.SettingKeyVariable in [
PyplotPlotKeyStr,
PyplotScatterKeyStr,
PyplotBarKeyStr
]:
#/####################/#
# first maybe pyplot if it was not already
#
#debug
'''
self.debug(
[
'we maybe pyplot first',
]
)
'''
#pyplot
self.pyplot()
#/####################/#
# Then add in the plot
#
#debug
'''
self.debug(
[
'before plot',
('self.',self,[
#'PyplotedParentFigureDerivePyploterVariable',
'SettingValueVariable'
])
]
)
'''
#init
PyplotPlotArgumentDict=Setter.ArgumentDict(
self.SettingValueVariable,
self.PyplotedParentFigureDerivePyploterVariable
)
#debug
'''
self.debug(
[
'We plot here',
'PyplotPlotArgumentDict is',
SYS._str(PyplotPlotArgumentDict)
]
)
'''
#plot
self.PyplotedLinesList.append(
self.PyplotedAxesVariable.plot(
*PyplotPlotArgumentDict['LiargVariablesList'],
**PyplotPlotArgumentDict['KwargVariablesDict']
)[0]
)
#debug
'''
self.debug(
[
('self.',self,['PyplotedLinesList']),
#str(self.PyplotedLinesList[0][0]),
]
)
'''
#return
return {'HookingIsBool':False}
elif self.SettingKeyVariable==PyplotAxesKeyStr:
#debug
'''
self.debug(
[
'before axes',
('self.',self,[
#'PyplotedParentFigureDerivePyploterVariable',
'PyplotedAxesVariable'
])
]
)
'''
#map
ArgumentTuplesList=map(
lambda __ItemTuple:
(
__ItemTuple[0],
Setter.ArgumentDict(
__ItemTuple[1],
self.PyplotedParentFigureDerivePyploterVariable
)
),
SYS.SetList(
self.SettingValueVariable
)
)
#debug
'''
self.debug(
[
'We axe here',
'ArgumentTuplesList is ',
SYS._str(ArgumentTuplesList),
]
)
'''
#map
map(
lambda __ArgumentTuple:
SYS.get(
self.PyplotedAxesVariable,
__ArgumentTuple[0]
)()
if len(__ArgumentTuple[1]['LiargVariablesList']
)==0 and __ArgumentTuple[1]['KwargVariablesDict']==None
else(
SYS.get(
self.PyplotedAxesVariable,
__ArgumentTuple[0]
)(**__ArgumentTuple[1]['KwargVariablesDict'])
if len(__ArgumentTuple[1]['LiargVariablesList']
)==0
else(
SYS.get(
self.PyplotedAxesVariable,
__ArgumentTuple[0]
)(
*__ArgumentTuple[1]['LiargVariablesList'],
**__ArgumentTuple[1]['KwargVariablesDict']
)
if __ArgumentTuple[1]['KwargVariablesDict']!=None
else
SYS.get(
self.PyplotedAxesVariable,
__ArgumentTuple[0]
)(
*__ArgumentTuple[1]['LiargVariablesList']
)
)
),
ArgumentTuplesList
)
#return
return {'HookingIsBool':False}
elif type(self.SettingKeyVariable)==str and self.SettingKeyVariable.startswith(
PyplotMpld3KeyStr):
#deprefix
ToolTipKeyStr=SYS.deprefix(
self.SettingKeyVariable,
PyplotMpld3KeyStr
)
#debug
'''
self.debug(
[
'before plugins',
('self.',self,['PyplotedParentFigureDerivePyploterVariable'])
]
)
'''
#init
PyplotPluginArgumentDict=Setter.ArgumentDict(
self.SettingValueVariable,
self.PyplotedParentFigureDerivePyploterVariable
)
#debug
'''
self.debug(
[
'We plugin here',
'PyplotPluginArgumentDict is ',
SYS._str(PyplotPluginArgumentDict)
]
)
'''
#plugin
from mpld3 import plugins
self.PyplotTooltipVariablesList=map(
lambda __PyplotCartoonVariable:
getattr(
plugins,
ToolTipKeyStr
)(
*[
__PyplotCartoonVariable
]+PyplotPluginArgumentDict['LiargVariablesList'],
**PyplotPluginArgumentDict['KwargVariablesDict']
),
self.PyplotedLinesList
)
#debug
'''
self.debug(
[
('self.',self,['PyplotTooltipVariablesList'])
]
)
'''
#connect
map(
lambda __PyplotTooltipVariable:
plugins.connect(
self.PyplotedFigureVariable,
__PyplotTooltipVariable
),
self.PyplotTooltipVariablesList
)
#return
return {'HookingIsBool':False}
#we set a Chart
#call the base method
BaseClass.set(self)
def recordTrace(self):
#/###################/#
# Traces level
#
#debug
"""
self.debug(
[
'This is the Traces level',
'First get the array to trace',
('self.',self,[
'RecordingKeyVariable'
])
]
)
"""
#get
RecordedTopDeriveRecorderVariable=self.ParentDeriveTeamerVariable.ParentDeriveTeamerVariable
#/##################/#
# First get the array to trace
#
#get
if type(self.RecordingKeyVariable)==None.__class__:
#Check
if RecordPrefixStr!="" and self.ManagementTagStr.startswith(RecordPrefixStr):
#debug
'''
self.debug(
[
('self.',self,['ManagementTagStr']),
'RecordedTopDeriveRecorderVariable is '+str(RecordedTopDeriveRecorderVariable)
]
)
'''
#get
self.RecordedTraceFloatsArray=getattr(
RecordedTopDeriveRecorderVariable,
SYS.deprefix(
self.ManagementTagStr,
RecordPrefixStr
)
)
elif type(self.RecordingKeyVariable).__name__!='ndarray':
#get
self.RecordedTraceFloatsArray=RecordedTopDeriveRecorderVariable[
self.RecordingKeyVariable
]
else:
#alias
self.RecordedTraceFloatsArray=self.RecordingKeyVariable
#alias
if self.RecordKeyStr=="":
self.RecordKeyStr=str(self.RecordingKeyVariable)
#debug
'''
self.debug(
[
'We have getted the RecordedTraceFloatsArray',
('self.',self,['RecordedTraceFloatsArray']),
'Now set the init'
]
)
'''
#Check
if type(self.RecordedTraceFloatsArray)!=None.__class__:
#/##################/#
# Prepare initial conditions
# with the Matrixer
#Check
if type(self.RecordingInitFloatsArray)==None.__class__:
#debug
'''
self.debug(
[
'We prepare the initial conditions',
'len(self.RecordedTraceFloatsArray) is ',
str(len(self.RecordedTraceFloatsArray)),
('self.',self,[
'NumscipyingStdFloat',
'NumscipyingMeanFloat',
'RecordedTraceFloatsArray'
])
]
)
'''
#Check
if self.RecordingInitStdVariable!=None:
#set
self.NumscipyingStdFloat=self.RecordingInitStdVariable
elif RecordedTopDeriveRecorderVariable.RecordingInitStdVariable!=None:
#set
self.NumscipyingStdFloat=RecordedTopDeriveRecorderVariable.RecordingInitStdVariable
#Check
if self.RecordingInitMeanVariable!=None:
#set
self.NumscipyingMeanFloat=self.RecordingInitMeanVariable
elif RecordedTopDeriveRecorderVariable.RecordingInitMeanVariable!=None:
#set
self.NumscipyingMeanFloat=RecordedTopDeriveRecorderVariable.RecordingInitMeanVariable
#matrix
self.RecordedInitFloatsArray=self.numscipy(
_SizeTuple=(len(self.RecordedTraceFloatsArray),1),
_StatBool=False
).NumscipiedValueFloatsArray[:,0]
else:
#debug
'''
self.debug(
[
"we init with a fix array",
('self.',self,[
'RecordingInitFloatsArray'
])
]
)
'''
#alias
self.RecordedInitFloatsArray = self.RecordingInitFloatsArray
#debug
'''
def mimic_set(self):
#Definition
OutputDict={'HookingIsBool':True}
#debug
'''
self.debug(('self.',self,['SettingKeyVariable']))
'''
#Check
if type(
self.SettingKeyVariable
)==str:
#Check
if self.SettingKeyVariable.startswith(
ManagementDirectChildPrefixStr
):
#debug
'''
self.debug(
[
'We manage here without instancing',
('self.',self,['SettingKeyVariable'])
]
)
'''
#manage
self.manage(
SYS.deprefix(
self.SettingKeyVariable,
ManagementDirectChildPrefixStr
),
self.SettingValueVariable,
_WrapBool=False
)
self.ManagingWrapBool=True
#Stop the setting
return {'HookingIsBool':False}
elif self.SettingKeyVariable.startswith(
ManagementChildPrefixStr
):
#debug
'''
self.debug('We manage here')
'''
#manage
self.manage(
SYS.deprefix(
self.SettingKeyVariable,
ManagementChildPrefixStr
),
self.SettingValueVariable
)
#Stop the setting
return {'HookingIsBool':False}
#debug
'''
self.debug(
[
'Call the base set method',
'BaseClass is '+str(BaseClass),
('self.',self,['SettingKeyVariable'])
]
)
'''
#return
return BaseClass.set(self)
def mimic_get(self):
#debug
'''
self.debug(
('self.',self,[
'GettingKeyVariable',
])
)
'''
#Check
if type(self.GettingKeyVariable)==str:
#Check
if self.GettingKeyVariable.startswith(
PointToStr
):
#debug
'''
self.debug(
'we point here'
)
'''
#point
self.point(
SYS.deprefix(
self.GettingKeyVariable,
PointToStr
)
)
#alias
self.GettedValueVariable=self.PointedToVariable
#return
return {'HookingIsBool':False}
elif self.GettingKeyVariable.startswith(
PointBackStr
):
#debug
'''
self.debug(
'we back point here'
)
'''
#point
self.point(
SYS.deprefix(
self.GettingKeyVariable,
PointBackStr
),
_BackBool=True
)
#alias
self.GettedValueVariable=self.PointedToVariable
#return
return {'HookingIsBool':False}
elif self.GettingKeyVariable.startswith(
PointPrefixStr
):
#debug
'''
self.debug(
'we get the encapsulate variable'
)
'''
#deprefix
PointGetKeyStr=SYS.deprefix(
self.GettingKeyVariable,
PointPrefixStr
)
#get
self.GettedValueVariable=self[PointGetKeyStr]['PointToVariable']
#return
return {'HookingIsBool':False}
#call the base method
return BaseClass.get(self)
def mimic_set(self):
#Check
if type(self.SettingKeyVariable)==str:
#Check
if self.SettingKeyVariable.startswith(ConnectGetSetPrefixStr):
if type(
self.SettingValueVariable
)==list and SYS.getIsTuplesListBool(self.SettingValueVariable
)==False and len(self.SettingValueVariable)==2:
#debug
'''
self.debug(
[
'We set connect here',
('self.',self,['SettingKeyVariable'])
]
)
'''
#connect
self.connect(
SYS.deprefix(
self.SettingKeyVariable,
ConnectGetSetPrefixStr
),
self.SettingValueVariable[0],
self.SettingValueVariable[1]
)
#return
return {'HookingIsBool':False}
else:
#debug
'''
self.debug(
[
'We set connect back here',
('self.',self,['SettingKeyVariable'])
]
)
'''
#connect
self.connect(
SYS.deprefix(
self.SettingKeyVariable,
ConnectGetSetPrefixStr
),
self.SettingValueVariable
)
#return
return {'HookingIsBool':False}
#set
BaseClass.set(self)
def do__class(self):
#Definition the MethodsList
ClassedFunctionsList=SYS._filter(
lambda __ListedVariable:
type(__ListedVariable).__name__=="function"
if hasattr(__ListedVariable,'__name__')
else False,
self.DoClass.__dict__.values()
)
#debug
'''
print('l 66 Classer')
print("ClassedFunctionsList is ",WatchedFunctionsList)
print('Set all the mimick methods')
print('')
'''
#/###################/#
# Mimic all that you can find
#
#Get all the hooking methods
ClassedMimickFunctionsList=SYS._filter(
lambda __ListedVariable:
__ListedVariable.__name__.startswith(
Mimicker.MimickingWrapPrefixStr
)
if hasattr(__ListedVariable,'__name__')
else False,
ClassedFunctionsList
)
#debug
'''
print('l 82 Classer')
print("ClassedMimickFunctionsList is ",ClassedMimickFunctionsList)
print('')
'''
#map
map(
lambda __ClassedMimickFunction:
self.mimic(
Mimicker.MimickingWrapPrefixStr.join(
__ClassedMimickFunction.__name__.split(
Mimicker.MimickingWrapPrefixStr)[1:]
)
),
ClassedMimickFunctionsList
)
#/###################/#
# Set the watch methods
#
#debug
'''
print('l 104 Classer')
print('set the watch functions')
print('self.ClassingWatchMethodStrsList is ',self.ClassingWatchMethodStrsList)
print('self.DoClass.DoMethodStr is ',self.DoClass.DoMethodStr)
print('')
'''
#map
map(
lambda __ClassingWatchUnboundMethodStr:
self.watch(
True,
**{'ObservingWrapMethodStr':__ClassingWatchUnboundMethodStr}
),
self.ClassingWatchMethodStrsList
)
#/###################/#
# Set the switch methods
#
#debug
'''
print('l 104 Classer')
print('set the switch functions')
print('self.ClassingSwitchMethodStrsList is ',self.ClassingSwitchMethodStrsList)
print('self.DoClass.DoMethodStr is ',self.DoClass.DoMethodStr)
print('')
'''
#map
map(
lambda __ClassingSwitchUnboundMethodStr:
self.switch(
True,
__ClassingSwitchUnboundMethodStr
),
self.ClassingSwitchMethodStrsList
)
#/###################/#
# Check for overriden propertize_ methods
#
#Debug
'''
print('Classer l 125')
print('Check for overriden propertize_ methods ')
print('self.DoClass.InspectMethodDict')
print(self.DoClass.InspectMethodDict)
print('')
'''
#filter
ClassedPropertyNewMethodDict=dict(
SYS._filter(
lambda __MethodItemTuple:
__MethodItemTuple[0].startswith(
Propertiser.PropertyPrefixStr
) and (
SYS.getNewMethodBool(self.DoClass,__MethodItemTuple[0])
#getattr(
# self.DoClass.__bases__[0],
# __MethodItemTuple[0]
#)!=__MethodItemTuple[1]
#if hasattr(self.DoClass.__bases__[0],
# __MethodItemTuple[0]
#) else True
),
self.DoClass.InspectMethodDict.items()
)
)
#Debug
'''
print('Classer l 147')
print('self.DoClass is ')
print(self.DoClass)
print('ClassedPropertyNewMethodDict is')
print(SYS.indent(ClassedPropertyNewMethodDict))
print('')
'''
#map
ClassedPropertyKeyStrsList=map(
lambda __PropertizedKeyStr:
SYS.deprefix(
__PropertizedKeyStr,
Propertiser.PropertyPrefixStr
)[3:],
ClassedPropertyNewMethodDict.keys()
)
#map reset the properties
map(
lambda __PropertyKeyStr:
setattr(
self.DoClass,
__PropertyKeyStr,
property(
getattr(
self.DoClass,
Propertiser.PropertyPrefixStr+'get'+__PropertyKeyStr
),
getattr(
self.DoClass,
Propertiser.PropertyPrefixStr+'set'+__PropertyKeyStr
),
getattr(
self.DoClass,
Propertiser.PropertyPrefixStr+'del'+__PropertyKeyStr
)
)
),
ClassedPropertyKeyStrsList
)
#/###################/#
# Set maybe a structure
#
#Check
if self.ClassingStructureVariable!=None:
#Check
if hasattr(
self.ClassingStructureVariable,'items'
):
ClassedStructureVariable=self.ClassingStructureVariable.items()
else:
ClassedStructureVariable=self.ClassingStructureVariable
#debug
'''
print('Classer l 241')
print('We structure here')
print('self.ClassingStructureVariable is ')
print(self.ClassingStructureVariable)
print('')
'''
#map add the sing plurals
map(
lambda __ItemTuple:
SYS.addSingPlural(
*__ItemTuple
),
ClassedStructureVariable
)
#Define a class
class StructureClass(SYS.StructurerClass):pass
StructureClass.__name__=SYS.getClassStrWithNameStr(self.DoClass.NameStr+'sStructurer')
StructureClass.ManagingValueClass=self.DoClass
#set
setattr(
self.Module,
StructureClass.__name__,
StructureClass
)
#dict
ClassesDict=dict(
map(
lambda __ItemTuple:
(__ItemTuple[1],StructureClass),
ClassedStructureVariable
)
)
#map
if self.DoClass.TeamingClassesDict==None:
self.DoClass.TeamingClassesDict=ClassesDict
else:
self.DoClass.TeamingClassesDict.update(
ClassesDict
)
def mimic_set(self):
#Check
if type(self.SettingKeyVariable)==str and self.SettingKeyVariable.startswith(
ParentMutePrefixStr
):
#deprefix
MuteGetKeyStr=SYS.deprefix(
self.SettingKeyVariable,
ParentMutePrefixStr
)
#get
MuteGetValueVariable=self[MuteGetKeyStr]
#init
#MuteSetValueVariable=self.SettingValueVariable()['#map@set'](
# MuteGetValueVariable.__dict__
#)
MuteSetValueVariable=self.SettingValueVariable()
MuteSetValueVariable.__dict__=MuteGetValueVariable.__dict__
#debug
'''
self.debug(
[
'We are going to mute...',
'MuteGetKeyStr is '+str(MuteGetKeyStr),
'MuteGetValueVariable.TeamTagStr is '+str(MuteGetValueVariable.TeamTagStr),
'MuteGetValueVariable.ManagementTagStr is '+str(MuteGetValueVariable.ManagementTagStr),
('self.',self,['SettingValueVariable']),
'MuteSetValueVariable is ',
SYS._str(MuteSetValueVariable)
]
)
'''
#Check
if MuteGetValueVariable.ParentDeriveTeamerVariable.TeamedOnceBool:
#debug
'''
self.debug(
'We team again'
)
'''
#del
del MuteGetValueVariable.ParentDeriveTeamerVariable.TeamDict[
MuteGetValueVariable.TeamTagStr
]
#team again
MuteGetValueVariable.ParentDeriveTeamerVariable.team(
MuteGetValueVariable.TeamTagStr,
MuteSetValueVariable
)
#return
return {'HookingIsBool':False}
else:
#debug
'''
self.debug(
'We manage again'
)
'''
#del
del MuteGetValueVariable.ParentDeriveTeamerVariable.ManagementDict[
MuteGetValueVariable.ManagementTagStr
]
#manage again
MuteGetValueVariable.ParentDeriveTeamerVariable.manage(
MuteGetValueVariable.ManagementTagStr,
MuteSetValueVariable
)
#return
return {'HookingIsBool':False}
#Call the base method
BaseClass.set(self)
def do_trace(self):
#/##################/#
# Find the parent recorder
#
#debug
'''
self.debug(
[
'We trace here',
'Networker.NetworkInTeamKeyStr in self.TeamDict is ',
str(Networker.NetworkInTeamKeyStr in self.TeamDict),
#('self.',self,['NetworkDeriveNetworkerVariable']),
'self.TeamDict.keys() is ',
str(self.TeamDict.keys()),
'Networker.NetworkInTeamKeyStr is ',
Networker.NetworkInTeamKeyStr
]
)
'''
"""
#Check
if Networker.NetworkInTeamKeyStr in self.TeamDict:
#debug
'''
self.debug(
[
'self.TeamDict[Networker.NetworkInTeamKeyStr].ManagementDict.keys() is ',
str(self.TeamDict[Networker.NetworkInTeamKeyStr].ManagementDict.keys())
]
)
'''
#get
self.TraceDeriveRecorderVariable=self.TeamDict[
Networker.NetworkInTeamKeyStr
].ManagementDict[Pointer.PointManagementPrefixStr+'Recorder'].PointToVariable
#debug
'''
self.debug(
[
'Ok we have setted the TraceDeriveRecorderVariable',
('self.',self,['TraceDeriveRecorderVariable'])
]
)
'''
"""
#debug
'''
self.debug(
[
'We set the TraceDeriveRecorderVariable
('self.',self,['ParentDeriveTeamerVariable'])
]
)
'''
#get
self.TraceDeriveRecorderVariable=self.ParentDeriveTeamerVariable.ParentDeriveTeamerVariable
#/##################/#
# First get the array to trace
#
#debug
'''
self.debug(
[
'We trace here',
('self.',self,['TracingKeyVariable'])
]
)
'''
#get
if type(self.TracingKeyVariable)==None.__class__:
#Check
if self.ManagementTagStr.startswith(TracerPrefixStr):
#get
self.TracedValueFloatsArray=getattr(
self.TraceDeriveRecorderVariable,
SYS.deprefix(
self.ManagementTagStr,
TracerPrefixStr
)
)
elif type(self.TracingKeyVariable).__name__!='ndarray':
#get
self.TracedValueFloatsArray=self.TraceDeriveRecorderVariable[
self.TracingKeyVariable
]
else:
#alias
self.TracedValueFloatsArray=self.TracingKeyVariable
#alias
if self.TraceKeyStr=="":
self.TraceKeyStr=str(self.TracingKeyVariable)
#debug
'''
self.debug(
[
'We have setted the TracedValueFloatsArray'
]
)
'''
#Check
if type(self.TracedValueFloatsArray)!=None.__class__:
#/##################/#
# Prepare initial conditions
# with the Matrixer
#debug
'''
self.debug(
[
'We prepare the initial conditions',
'len(self.TracedValueFloatsArray) is ',
str(len(self.TracedValueFloatsArray))
]
)
'''
#matrix
self.TracedInitFloatsArray=self.matrix(
_SizeTuple=(len(self.TracedValueFloatsArray),1)
).MatrixedRandomFloatsArray[:,0]
#debug
'''
def mimic_set(self):
#debug
self.debug(
('self.',self,[
'SettingKeyVariable',
'SettingValueVariable'
]))
#Definition
OutputDict={'HookingIsBool':True}
#Check
if self.SettingKeyVariable!="":
#Init
SettingKeyVariable=""
#Check
#if (self.SettingKeyVariable[0].isalpha() or self.SettingKeyVariable[:2]=="__"
# ) and self.SettingKeyVariable[0].lower()==self.SettingKeyVariable[0]:
if type(self.SettingValueVariable)==ApplyDictClass:
#set
SettingKeyVariable=self.SettingKeyVariable
#Check
if type(
self.SettingKeyVariable
)==str and self.SettingKeyVariable.startswith(
ApplySetPrefixStr
):
#debug
self.debug(
'We do an apply here with a deprefix settingkeyvariable'
)
#set
SettingKeyVariable=SYS.deprefix(
self.SettingKeyVariable,
ApplySetPrefixStr
)
#Check
if SettingKeyVariable!="":
#debug
self.debug('We do an apply with '+SettingKeyVariable)
#apply
self.apply(
SettingKeyVariable,
self.SettingValueVariable
)
#Return
OutputDict['HookingIsBool']=False
#<Hook>return OutputDict
if OutputDict['HookingIsBool']:
BaseClass.set(self)
def mimic_set(self):
""" """
#debug
'''
self.debug(
('self.',self,[
'SettingKeyVariable',
'SettingValueVariable'
]))
'''
#Definition
OutputDict={'HookingIsBool':True}
#Deep set
if type(
self.SettingKeyVariable
)==str and self.SettingKeyVariable.startswith(
PathPrefixStr
):
#deprefix
SetKeyVariable=SYS.deprefix(self.SettingKeyVariable,PathPrefixStr)
#Check
if PathPrefixStr not in SetKeyVariable:
#set
self.set(
SetKeyVariable,
self.SettingValueVariable
)
#stop the set
return {'HookingIsBool':False}
#debug
'''
self.debug('We are going to path')
'''
#Path
self.path(self.SettingKeyVariable)
#debug
'''
self.debug(('self.',self,[
"PathedGetKeyStr",
"PathedChildKeyStr",
"PathedGetValueVariable"
]
))
'''
#set
#Direct update in the Child or go deeper with the ChildPathStr
if self.SettingKeyVariable[-1]==PathPrefixStr:
#debug
'''
self.debug('this is a special set inside the pathed variable')
'''
#Check
if self.PathedGetValueVariable!=None:
#Case where it is an object to set inside
if 'PatherClass' in map(
lambda __Class:
__Class.__name__,
type(self.PathedGetValueVariable).__mro__
):
#debug
'''
self.debug(('self.',self,[
'PathedGetKeyStr',
'SettingKeyVariable',
'SettingValueVariable',
'PathedGetValueVariable'
]))
'''
#Modify directly the PathedGetValueVariable with self.SettingValueVariable
self.PathedGetValueVariable.__setitem__(
self.SettingValueVariable[0],
self.SettingValueVariable[1]
)
#Case where it is a set at the level of self of an already setted thing
else:
#set to the corresponding point
self[self.PathedGetKeyStr]=self.SettingValueVariable
else:
#debug
'''
self.debug(
[
'set with setWithPathVariableAndKeyVariable',
("self.",self,[
'SettingValueVariable',
'PathedChildKeyStr'])
]
)
'''
#Call the setWithPathVariableAndKeyVariable
setWithPathVariableAndKeyVariable(
self.PathedGetValueVariable,
self.PathedChildKeyStr,
self.SettingValueVariable
)
#Case where it is a set at the level of self of new setted thing
else:
#debug
'''
self.debug(
[
'we setitem here',
('self.',self,['PathedKeyStrsList'])
]
)
'''
#Check
if self.PathedGetKeyStr!="" and len(
self.PathedKeyStrsList
)==2:
#debug
'''
self.debug('we setitem at this level')
'''
#set
self[self.PathedGetKeyStr]=self.SettingValueVariable
else:
#define
ChildSettingKeyStr=PathPrefixStr+PathPrefixStr.join(
self.PathedKeyStrsList[2:]
)
#debug
'''
self.debug(
[
'we setitem further',
'ChildSettingKeyStr is '+ChildSettingKeyStr
]
)
'''
#set
self.PathedGetValueVariable[
ChildSettingKeyStr
]=self.SettingValueVariable
#Stop the setting
OutputDict["HookingIsBool"]=False
#Call the parent get method
if OutputDict['HookingIsBool']:
return BaseClass.set(self)
else:
return OutputDict
def do(self,_Class):
#set
self.DoClass=_Class
#debug
'''
print("Doer l.337 : self.DoClass is ",self.DoClass)
print('')
'''
#alias
DoClass=self.DoClass
#Definition
DoerStr=DoClass.NameStr
DoStr=DoerStrToDoStrOrderedDict[DoerStr]
DoMethodStr=DoStr[0].lower()+DoStr[1:] if DoStr[0]!='_' else '_'+DoStr[1].lower()+DoStr[2:]
DoneStr=DoStrToDoneStrOrderedDict[DoStr]
DoingStr=DoneStrToDoingStrOrderedDict[DoneStr]
LocalVariablesDict=vars()
#debug
'''
print('Doer l.275 : DoerStr is '+DoerStr)
print('DoStr is '+DoStr)
print('DoMethodStr is '+DoMethodStr)
print('DoingStr is '+DoingStr)
print('DoneStr is '+DoneStr)
print('')
'''
#set
map(
lambda __KeyStr:
setattr(DoClass,__KeyStr,LocalVariablesDict[__KeyStr]),
['DoerStr','DoStr','DoneStr','DoingStr','DoMethodStr']
)
#set a lists that will contain the tempory setting items during a call of the <do> method in the instance
#DoClass.DoHistoryOrderedDict=collections.OrderedDict()
#Check
if hasattr(DoClass,'DefaultAttributeVariablesOrderedDict'):
#Debug
'''
print('Doer l.383')
print('DoClass.DefaultAttributesVariablesOrderedDict is ',_Class.DefaultAttributesVariablesOrderedDict)
print('')
'''
#Check for doing and done keyStrs
DoClass.DoneAttributeVariablesOrderedDict=collections.OrderedDict(
SYS._filter(
lambda __DefaultAttributeItemTuple:
__DefaultAttributeItemTuple[0].startswith(DoneStr),
DoClass.DefaultAttributeVariablesOrderedDict.items()
)
)
DoClass.DoingAttributeVariablesOrderedDict=collections.OrderedDict(
SYS._filter(
lambda __DefaultAttributeItemTuple:
__DefaultAttributeItemTuple[0].startswith(DoingStr),
DoClass.DefaultAttributeVariablesOrderedDict.items()
)
)
DoClass.DoingDeprefixAttributeStrsList=map(
lambda __KeyStr:
DoingAttributePrefixStr+SYS.deprefix(__KeyStr,DoingStr),
DoClass.DoingAttributeVariablesOrderedDict.keys()
)
#Definition
DoWrapMethodStr=DoingWrapPrefixStr+DoMethodStr
#Debug
'''
print('Doer l.401')
print('DoClass.DoneAttributeVariablesOrderedDict is ',DoClass.DoneAttributeVariablesOrderedDict)
print('DoClass.DoingAttributeVariablesOrderedDict is ',DoClass.DoingAttributeVariablesOrderedDict)
print('DoWrapMethodStr is ',DoWrapMethodStr)
print('')
'''
#Check
if hasattr(DoClass,DoWrapMethodStr):
#Debug
'''
print('There is a DoWrapMethod here already')
print('')
'''
#Get
DoWrapMethod=getattr(
DoClass,
DoWrapMethodStr
)
else:
#Debug
'''
print('There is no DoWrapMethod here')
print('')
'''
#Definition of a default function
DoWrapMethod = DefaultDoFunction
#set
setattr(DoClass,DoWrapMethodStr,DoWrapMethod)
#debug
'''
print('DoWrapMethod is '+str(DoWrapMethod))
print('')
'''
#Link
"""
DoingMethodKeyStr='init'+DoClass.NameStr
setattr(
DoClass,
DoingMethodKeyStr,
initDo
)
"""
#/#################/#
# Define the shape of the args
#
#Definition of the ExecStr that will define the function
DoDecorationMethodStr=DoingDecorationPrefixStr+DoingDecorationTagStr+DoingDecorationSuffixStr+DoMethodStr
DoExecStr="def "+DoDecorationMethodStr+"(_InstanceVariable,"
DoExecStr+=",".join(
map(
lambda __DoingDeprefixAttributeStr:
#DoingAttributePrefixStr+__KeyStr+"=None",
__DoingDeprefixAttributeStr+"=None",
#DoClass.DoingAttributeVariablesOrderedDict.keys()
DoClass.DoingDeprefixAttributeStrsList
)
)
DoExecStr+="," if DoExecStr[-1]!="," else ""
DoExecStr+="*_LiargVariablesList,"
DoExecStr+="**_KwargVariablesDict):\n\t"
#/#################/#
# Set the doing variables
#
#Debug part
#DoExecStr+='\n\tprint("In '+DoDecorationMethodStr+' with '+DoWrapMethod.__name__+' ") '
'''
DoExecStr+="\n\t#Debug"
DoExecStr+=('\n\t'+';\n\t'.join(
map(
lambda __KeyStr:
'print("In DoerFunction, '+DoingAttributePrefixStr+__KeyStr+' is ",'+DoingAttributePrefixStr+__KeyStr+')',
_Class.DoingAttributeVariablesOrderedDict.keys()
)
)+";") if len(_Class.DoingAttributeVariablesOrderedDict.keys())>0 else ''
DoExecStr+='\n\tprint("_LiargVariablesList is ",_LiargVariablesList);'
DoExecStr+='\n\tprint("_KwargVariablesDict is ",_KwargVariablesDict);\n\t'
'''
#join
DoExecStr+=("\n"+";\n".join(
map(
lambda __KeyStr,__DoingDeprefixAttributeStr:
"\n".join(
[
#"\tif type("+DoingAttributePrefixStr+__KeyStr+")!=None.__class__:",
#"\t\t_InstanceVariable."+__KeyStr+"="+DoingAttributePrefixStr+__KeyStr,
"\tif type("+__DoingDeprefixAttributeStr+")!=None.__class__:",
"\t\t_InstanceVariable."+__KeyStr+"="+__DoingDeprefixAttributeStr,
]
),
DoClass.DoingAttributeVariablesOrderedDict.keys(),
DoClass.DoingDeprefixAttributeStrsList
)
)+";\n") if len(
DoClass.DoingAttributeVariablesOrderedDict.keys()
)>0 else ''
#Give to the class this part (it can serve after for imitating methods...)
DoExecStrKeyStr='Do'+DoClass.NameStr+'ExecStr'
setattr(DoClass,DoExecStrKeyStr,DoExecStr)
#Call the initDo method
DoExecStr+="\n" if DoExecStr[-1]!="\n" else ""
DoExecStr+="\n\t#return\n\t"
#Check
setattr(DoClass,'DoingGetBool',self.DoingGetBool)
if self.DoingGetBool==False:
#Return the _InstanceVariable if it is not a getter object
DoExecStr+="do(_InstanceVariable,"
DoExecStr+="*_LiargVariablesList,"
DoExecStr+="**dict(_KwargVariablesDict,**{'DoDecorationMethodStr':'"+DoDecorationMethodStr+"','DoClassStr':'"+DoClass.__name__+"'}))\n\t"
DoExecStr+="return _InstanceVariable\n"
else:
#Return the output of the do method
DoExecStr+="return do(_InstanceVariable,"
DoExecStr+="*_LiargVariablesList,"
DoExecStr+="**dict(_KwargVariablesDict,**{'DoDecorationMethodStr':'"+DoDecorationMethodStr+"','DoClassStr':'"+DoClass.__name__+"'}))\n"
#Debug
'''
print('Doer l 546')
print('DoExecStr is ')
print(DoExecStr)
print('')
'''
#exec
six.exec_(DoExecStr)
#set
#locals(
# )[DoDecorationMethodStr].DoWrapMethod=DoWrapMethod
#Debug
'''
print('l. 907 Doer')
print('DoClass is ',DoClass)
print('DoDecorationMethodStr is ',DoDecorationMethodStr)
print('DoWrapMethod is ',DoWrapMethod)
print("locals()[DoDecorationMethodStr] is ",locals()[DoDecorationMethodStr])
print('')
'''
#set with the specific name
self.setMethod(DoDecorationMethodStr,locals()[DoDecorationMethodStr])
#set with the DoMethodStr shortcut
self.setMethod(DoMethodStr,locals()[DoDecorationMethodStr])
#set a pointer to the fundamental class
locals()[DoDecorationMethodStr].BaseDoClass=DoClass
#/####################/#
# Set maybe if not already the setDo methods
#
#Check
if hasattr(DoClass,'setDo')==False:
#Debug
'''
print('Doer l 602')
print('DoClass is')
print(DoClass)
print('')
'''
#map
map(
lambda __SetUnboundMethod:
#set with the DoMethodStr shortcut
self.setMethod(
__SetUnboundMethod.__name__,
__SetUnboundMethod
),
[
getDo,getDoing,getDone,
setDo,setDoing,setDone,
callDo
]
)
#/####################/#
# Give a list of all the mro Doer and the do possible
#
#set a DoMethodStrsList
if hasattr(DoClass.__bases__[0],'MroDoerClassesList'):
DoClass.MroDoerClassesList=DoClass.__bases__[0
].MroDoerClassesList+[DoClass]
else:
DoClass.MroDoerClassesList=[DoClass]
#set a DoMethodStrsList
if hasattr(DoClass.__bases__[0],'DoMethodStrsList'):
DoClass.DoMethodStrsList=DoClass.__bases__[0
].DoMethodStrsList+[DoMethodStr]
else:
DoClass.DoMethodStrsList=[DoMethodStr]
#Check
DoClass.DoUnitsInt=-1
#Add to the KeyStrsList
DoClass.KeyStrsList+=[
'DoerStr',
'DoStr',
'DoneStr',
'DoingStr',
'DoneAttributeVariablesOrderedDict',
'DoingAttributeVariablesOrderedDict',
'DoingDeprefixAttributeStrsList',
'DoMethodStr',
'DoHistoryOrderedDict',
DoExecStrKeyStr,
'DoingGetBool',
'DoTempAttributeItemTuplesList',
'DoTempNotAttributeItemTupleItemsList',
'DoMethodStrsList',
'MroDoerClassesList',
'DoUnitsInt'
]
def do_set(self):
""" """
#debug
'''
self.debug(
("self.",self,[
'SettingKeyVariable',
'SettingValueVariable'
])
)
'''
#itemize first
if self.SettingItemBool:
#debug
'''
self.debug('first we itemize')
'''
#itemize
self.itemize(
self.SettingKeyVariable
)
else:
#set
self.ItemizedValueMethod=None
#/############################
# Case of a method get
#
#debug
'''
self.debug(
('self.',self,['ItemizedValueMethod'])
)
'''
#Check
if self.ItemizedValueMethod!=None:
#debug
'''
self.debug(
[
'we are going to call the method but first get it',
('self.',self,['ItemizedValueMethod'])
]
)
'''
#/####################/#
# Get the method and init the liarg and kwarg
#
#get
SettedValueMethod=self[self.SettingKeyVariable]
#alias
SettedLiargVariable=self.SettingValueVariable
SettedKwargVariable=None
#/####################/#
# Check for an argument dict
#
#debug
'''
self.debug(
[
'SettedValueMethod is '+SYS._str(SettedValueMethod),
'Before calling the itemized method, we adapt the liarg',
('self.',self,['SettingValueVariable'])
]
)
'''
#Check
if hasattr(
self.SettingValueVariable,'items'
):
#Check
if any(
map(
lambda __KeyStr:
__KeyStr in self.SettingValueVariable,
[
SetLiargGrabStr,
SetMapLiargGetGrabStr,
SetLiargGetGrabStr,
SetKwargGrabStr,
SetMapKwargGetKeyGrabStr,
SetMapKwargGetKeyValueGrabStr
]
)
):
#debug
'''
self.debug(
[
'It is an argument dict'
]
)
'''
#get
[SettedLiargVariable,SettedKwargVariable]=map(
lambda __KeyStr:
ArgumentDict(
self.SettingValueVariable,
self
)[__KeyStr],
['LiargVariablesList','KwargVariablesDict']
)
#debug
'''
self.debug(
[
'SettedLiargVariable is '+SYS._str(SettedLiargVariable),
'SettedKwargVariable is '+SYS._str(SettedKwargVariable),
]
)
'''
#/#################/#
# Set a map lambda
#
elif SetLiargLambdaGrabStr in self.SettingValueVariable:
#debug
'''
self.debug(
[
'we set a value with a SetLiargLambdaGrabStr inside',
('self.',self,['SettingValueVariable'])
]
)
'''
#temp
SettedLambdaValueVariable=self.SettingValueVariable
SettedLambdaKeyVariable=self.SettingKeyVariable
#getMap
SettedMapLambdaList=self.getMapLambdaList(
SettedLambdaValueVariable
)
#debug
'''
self.debug(
[
'SettedMapLambdaList is',
str(SettedMapLambdaList)
]
)
'''
#map map set
map(
lambda __SettedVariable:
self.mapSet(__SettedVariable),
SettedMapLambdaList
)
#Stop the setting
return {"HookingIsBool":False}
#set
SettedIsBool=False
#define
if hasattr(SettedValueMethod,'im_func'):
#Check
if hasattr(SettedValueMethod.im_func,'BaseDoClass'):
#debug
'''
self.debug(
[
"hasattr(SettedValueMethod.im_func.BaseDoClass.Module,'getLiargVariablesList') is",
str(hasattr(SettedValueMethod.im_func.BaseDoClass.Module,'getLiargVariablesList'))
]
)
'''
#Check
if hasattr(
SettedValueMethod.im_func.BaseDoClass.Module,
'getLiargVariablesList'
):
#set
SettedIsBool=True
#get
SettedLiargVariablesList=SettedValueMethod.im_func.BaseDoClass.Module.getLiargVariablesList(
SettedLiargVariable
)
#debug
'''
self.debug(
'SettedLiargVariablesList is '+str(SettedLiargVariablesList)
)
'''
if SettedKwargVariable!=None:
#get the method and put the value as arguments
SettedValueMethod(*SettedLiargVariablesList,**SettedKwargVariable)
else:
#get the method and put the value as arguments
SettedValueMethod(*SettedLiargVariablesList)
#Stop the setting
return {"HookingIsBool":False}
if SettedIsBool==False:
#debug
'''
self.debug(
[
'call the SettedValueMethod with self.SettingValueVariable directly',
'SettedLiargVariable is '+SYS._str(SettedLiargVariable)
]
)
'''
#Check
if hasattr(SettedLiargVariable,'items'):
SettedLiargVariable=SettedLiargVariable.items()
elif type(SettedLiargVariable)!=list:
SettedLiargVariable=[SettedLiargVariable]
#Check
if SettedKwargVariable!=None:
#direct
#SettedValueMethod(*self.SettingValueVariable)
SettedValueMethod(*SettedLiargVariable,**SettedKwargVariable)
else:
#direct
#SettedValueMethod(*self.SettingValueVariable)
SettedValueMethod(*SettedLiargVariable)
#Stop the setting
return {"HookingIsBool":False}
#/####################/#
# Case of a non method with set with a set key str
#
elif type(
self.SettingKeyVariable
) in [str,unicode]:
#cast
self.SettingKeyVariable=str(self.SettingKeyVariable)
#/####################/#
# Case of #bound: set
#
#Check
if self.SettingKeyVariable.startswith(
SetBoundPrefixStr
):
#deprefix
SettedMethodStr=SYS.deprefix(
self.SettingKeyVariable,
SetBoundPrefixStr
)
#debug
'''
self.debug(
[
'We bound here',
'SettedMethodStr is '+SettedMethodStr
]
)
'''
#bound
setattr(
self.__class__,
SettedMethodStr,
self.SettingValueVariable
)
#call
self.SettingValueVariable(self)
#stop the setting
return {'HookingIsBool':False}
#/####################/#
# Case of #untype: set
#
#Check
elif self.SettingKeyVariable.startswith(
SetUntypePrefixStr
):
#set
self.SettingTypeBool=False
#get
SettedEachGetVariable=self.set(
SYS.deprefix(
self.SettingKeyVariable,
SetUntypePrefixStr
),
self.SettingValueVariable
)
#reset
self.SettingTypeBool=True
#Return stop the setting
return {'HookingIsBool':False}
#/####################/#
# Case of #each: set
#
#Check
elif self.SettingKeyVariable.startswith(
SetEachPrefixStr
):
#temp
SettedTempLiargSettingValueVariable=self.SettingValueVariable
#get
SettedEachGetVariable=self[
SYS.deprefix(
self.SettingKeyVariable,
SetEachPrefixStr
)
]
#debug
'''
self.debug(
[
'We each here',
('self.',self,['SettingKeyVariable']),
'SettedEachGetVariable is '+str(SettedEachGetVariable)
]
)
'''
#Check
if hasattr(SettedEachGetVariable,'values'):
SettedEachGetVariablesList=SettedEachGetVariable.values()
else:
SettedEachGetVariablesList=SettedEachGetVariable
#debug
'''
self.debug(
[
'SettedEachGetVariablesList is ',
SYS._str(SettedEachGetVariablesList),
'SettedTempLiargSettingValueVariable is ',
SYS._str(SettedTempLiargSettingValueVariable)
]
)
'''
#map
map(
lambda __SettedGetVariable,__SettedValueVariable:
__SettedGetVariable[SetMapStr](
SYS.SetList(__SettedValueVariable)
),
SettedEachGetVariablesList,
SettedTempLiargSettingValueVariable
)
#Return stop the setting
return {'HookingIsBool':False}
#/####################/#
# Case of #all: set
#
#Check
elif self.SettingKeyVariable.startswith(
SetAllPrefixStr
):
#get
SettedGetVariable=self[
SYS.deprefix(
self.SettingKeyVariable,
SetAllPrefixStr
)
]
#Check
if hasattr(SettedGetVariable,'values'):
SettedGetVariablesList=SettedGetVariable.values()
else:
SettedGetVariablesList=SettedGetVariable
#debug
'''
self.debug(
[
'SettedGetVariablesList is ',
SYS._str(SettedGetVariablesList),
('self.',self,['SettingValueVariable'])
]
)
'''
#Check
if type(self.SettingValueVariable) in [
list,tuple
] and len(self.SettingValueVariable)==2:
#map
map(
lambda __SettedGetVariable:
__SettedGetVariable.set(
*self.SettingValueVariable
),
SettedGetVariablesList
)
else:
#map
map(
lambda __SettedGetVariable:
__SettedGetVariable[SetMapStr](
self.SettingValueVariable
),
SettedGetVariablesList
)
#Return stop the setting
return {'HookingIsBool':False}
#/####################/#
# Case of #copy: set
#
#Check
elif self.SettingKeyVariable.startswith(
SetCopyPrefixStr
):
#deprefix
GetKeyStr=SYS.deprefix(
self.SettingKeyVariable,
SetCopyPrefixStr
)
#debug
'''
self.debug(
[
'We copy set here',
'GetKeyStr is ',
GetKeyStr
]
)
'''
#set
self[GetKeyStr]=copy.copy(self.SettingValueVariable)
#Return stop the setting
return {'HookingIsBool':False}
#Check
elif self.SettingKeyVariable.startswith(
SetDeepCopyPrefixStr
):
#deprefix
GetKeyStr=SYS.deprefix(
self.SettingKeyVariable,
SetDeepCopyPrefixStr
)
#debug
'''
self.debug(
[
'We deepcopy set here',
'GetKeyStr is ',
GetKeyStr
]
)
'''
#set
self[GetKeyStr]=copy.deepcopy(self.SettingValueVariable)
#Return stop the setting
return {'HookingIsBool':False}
#/####################/#
# Case of a set in the __dict__
#
else:
#/####################/#
# Case of a set with a #get in the value
#
if type(
self.SettingValueVariable
)==str and self.SettingValueVariable.startswith(SetUndirectPrefixStr):
#deprefix
SettedKeyStr=SYS.deprefix(
self.SettingValueVariable,
SetUndirectPrefixStr
)
#debug
'''
self.debug(
[
'This is a undirect of a str variable',
'SettedKeyStr is '+SettedKeyStr
]
)
'''
#Check
if SetUndirectPrefixStr in SettedKeyStr:
#split
SettedKeyStrsList=SettedKeyStr.split(SetUndirectPrefixStr)
#define
SettedRecursiveKeyStr=''.join(
SettedKeyStrsList[:-1])+self[SettedKeyStrsList[-1]]
#debug
'''
self.debug(
[
'This is a recursive undirect set',
'SettedRecursiveKeyStr is '+SettedRecursiveKeyStr
]
)
'''
#set
self[
self.SettingKeyVariable
]=SetUndirectPrefixStr+SettedRecursiveKeyStr
else:
#debug
'''
self.debug(
'This is one level undirect set'
)
'''
#set
self[
self.SettingKeyVariable
]=self[SettedKeyStr]
#Stop the getting
return {"HookingIsBool":False}
#/####################/#
# Case of a set with a set dict
#
#Check
elif hasattr(
self.SettingValueVariable,'items'
):
#debug
'''
self.debug(
[
'Check for a set value dict',
('self.',self,['SettingValueVariable'])
]
)
'''
if SetValueGrabStr in self.SettingValueVariable:
#debug
'''
self.debug(
[
'we set a value with a SetValueGrabStr inside',
('self.',self,['SettingValueVariable'])
]
)
'''
#set
self[self.SettingKeyVariable]=self.SettingValueVariable[SetValueGrabStr]
#Return
return {'HookingIsBool':False}
elif SetMapValueGetGrabStr in self.SettingValueVariable:
#debug
'''
self.debug(
[
'we set a value with a map SetMapValueGetGrabStr inside',
('self.',self,['SettingValueVariable'])
]
)
'''
#set
self[self.SettingKeyVariable]=self[
SYS.deprefix(
SetMapValueGetGrabStr,
SetValueGrabPrefixStr
)
](
*self.SettingValueVariable[SetMapValueGetGrabStr]
).ItemizedMapValueVariablesList
#Return
return {'HookingIsBool':False}
#Check
elif SetValueGetGrabStr in self.SettingValueVariable:
#Get
SettedGrabValueVariable=self[
self.SettingValueVariable[SetValueGetGrabStr]
]
#debug
'''
self.debug(
[
'we set a value with a SetValueGetGrabStr inside',
('self.',self,['SettingValueVariable']),
'SettedGrabValueVariable is '+SYS._str(
SettedGrabValueVariable)
]
)
'''
#set
self[
self.SettingKeyVariable
]=SettedGrabValueVariable
#Return
return {'HookingIsBool':False}
elif SetValueLambdaGrabStr in self.SettingValueVariable:
#debug
'''
self.debug(
[
'This is a lambda map set',
('self.',self,['SettingValueVariable'])
]
)
'''
#temp
SettedTempKeyVariable=self.SettingKeyVariable
SettedTempValueVariable=self.SettingValueVariable
#getMap
SettedReplaceValueVariablesList=self.getMapLambdaList(
SettedTempValueVariable
)
#set
self[SettedTempKeyVariable]=SettedReplaceValueVariablesList
#Return
return {'HookingIsBool':False}
#/####################/#
# Case of an instancing set
#
#Check
if self.SettingTypeBool:
#debug
'''
self.debug(
[
'we check if we have to set a default value here',
('self.',self,[
'SettingKeyVariable',
'SettingValueVariable'
])
]
)
'''
#get
SettedValueType=SYS.getTypeClassWithTypeStr(
SYS.getTypeStrWithKeyStr(
self.SettingKeyVariable)
)
#type
SettedSettingValueVariableType=type(self.SettingValueVariable)
#cast
if SettedSettingValueVariableType==unicode:
self.SettingValueVariable=str(self.SettingValueVariable)
SettedSettingValueVariableType=str
#Check
if SettedValueType!=SettedSettingValueVariableType:
#debug
'''
self.debug(
[
'Check that the type is not a lst and a numpy array'
]
)
'''
#Check
if set([
SettedValueType.__name__,
SettedSettingValueVariableType.__name__
])!=SetListTypesSet:
#debug
'''
self.debug(
[
'SettedValueType is '+str(SettedValueType),
('self.',self,['SettingKeyVariable'])
]
)
'''
#Check
if SettedValueType!=None.__class__:
#debug
'''
self.debug(
[
'we wrap the setting value',
('self.',self,['SettingValueVariable'])
]
)
'''
#alias
'''
try:
'''
#map set
self[self.SettingKeyVariable]=SettedValueType(
).mapSet(
self.SettingValueVariable
)
#self[self.SettingKeyVariable]=SettedValueType(
# )[SetMapStr](
# self.SettingValueVariable
#)
#self.SettingValueVariable=SettedValueType(
# )[SetMapValueGetGrabStr](
# self.SettingValueVariable
#)
'''
except:
#debug
self.debug(
[
'set failed because the suffix str indicates a different type from the value',
'SettedValueType is '+str(SettedValueType),
'type(self.SettingValueVariable) is '+str(
type(self.SettingValueVariable))
]
)
'''
#debug
'''
self.debug(
'Ok we have instanced'
)
'''
#Return
return {'HookingIsBool':False}
#/####################/#
# Check that it is not a property
#
#Check
if hasattr(self.__class__,self.SettingKeyVariable):
#get
SettedPropertyValueVariable=getattr(self.__class__,self.SettingKeyVariable)
#Check
if type(SettedPropertyValueVariable)==property:
#debug
'''
self.debug('It is a property set')
'''
#set the property
setattr(
self,
self.SettingKeyVariable,
self.SettingValueVariable
)
#Return
return {'HookingIsBool':False}
#/####################/#
# Set in the __dict__ ... finally
#
#debug
'''
self.debug(
[
'we just maybe set in the __dict__',
('self.',self,[
'SettingKeyVariable',
'SettingValueVariable'
])
]
)
'''
#__setitem__ in the __dict__, this is an utility set
self.__dict__[
self.SettingKeyVariable
]=self.SettingValueVariable
#/####################/#
# GIve maybe some things to the setted value
#
#add in the SettingValue
try:
self.SettingValueVariable.SetTagStr=self.SettingKeyVariable
self.SettingValueVariable.SetDeriveSetter=self
except:
pass
#Return
return {'HookingIsBool':False}
#/####################/#
# Case of a non method set with a set dict in the Key Variable
#
elif hasattr(self.SettingKeyVariable,'items'):
#get
SettedGetKeyVariable=self[self.SettingKeyVariable]
#debug
'''
self.debug(
[
'SettingKeyVariable has items...',
('self.',self,['SettingKeyVariable']),
'SettedGetKeyVariable is '+SYS._str(SettedGetKeyVariable)
]
)
'''
#set
self.set(
SettedGetKeyVariable,
self.SettingValueVariable
)
#Return
return {'HookingIsBool':False}
#/####################/#
# Case of a function set
#
elif callable(self.SettingKeyVariable):
#/####################/#
# Case of a non method with a set dict in the Value Variable
#
#debug
'''
self.debug(
[
'The key is callable',
('self.',self,[
'SettingValueVariable',
'PathDerivePather'
]),
'map get the values to have the liargvariables list'
]
)
'''
#Set
SettedTempKeyVariable=self.SettingKeyVariable
SettedLiargVariable=self.SettingValueVariable
SettedKwargVariable=None
#/####################/#
# Check for an argument dict
#
#Check
if hasattr(
SettedLiargVariable,'items'
):
#Check
if any(
map(
lambda __KeyStr:
__KeyStr in SettedLiargVariable,
[
SetLiargGrabStr,
SetMapLiargGetGrabStr,
SetLiargGetGrabStr,
SetKwargGrabStr,
SetMapKwargGetKeyGrabStr,
SetMapKwargGetKeyValueGrabStr
]
)
):
#debug
self.debug(
[
'It is a argument dict'
]
)
#get
[SettedLiargVariable,SettedKwargVariable]=map(
lambda __KeyStr:
ArgumentDict(
SettedLiargVariable,
self
)[__KeyStr],
['LiargVariablesList','KwargVariablesDict']
)
#debug
'''
self.debug(
[
'SettedLiargVariable is '+SYS._str(SettedLiargVariable),
'SettedKwargVariable is '+SYS._str(SettedKwargVariable),
]
)
'''
else:
#/###################/
# It is a get dict
#
#call a set to active the #value get
self.set(
'TempSetVariable',
SettedLiargVariable
)
#debug
'''
self.debug(
[
'This is a get dict ',
'self.TempSetVariable is '+SYS._str(self.TempSetVariable),
('self.',self,['SettingValueVariable'])
]
)
'''
#get
SettedLiargVariable=self.TempSetVariable if type(
self.TempSetVariable)==list else [self.TempSetVariable]
#delete
del self.__dict__['TempSetVariable']
#reupdate
self.SettingKeyVariable=SettedTempKeyVariable
#Check
if type(SettedLiargVariable)!=list:
#get
SettedLiargVariablesList=[SettedLiargVariable]
else:
#alias
SettedLiargVariablesList=SettedLiargVariable
#debug
'''
self.debug(
[
'we call here',
('self.',self,['SettingKeyVariable']),
'SettedLiargVariablesList is '+SYS._str(SettedLiargVariablesList)
]
)
'''
#call
if SettedLiargVariable!=None and SettedKwargVariable!=None:
self.SettingKeyVariable(
*SettedLiargVariablesList,
**SettedKwargVariable
)
else:
self.SettingKeyVariable(
*SettedLiargVariablesList
)
#debug
'''
self.debug(
'self.SettingKeyVariable.__self__ is '+SYS._str(
self.SettingKeyVariable.__self__
)
)
'''
#Return
return {'HookingIsBool':False}
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
)
)
#debug
'''
self.debug(
[
'We axe here',
'ArgumentTuplesList is ',
SYS._str(ArgumentTuplesList),
]
)
'''
#map
map(
lambda __ArgumentTuple:
SYS.get(
self.FiguredAxesVariable,
__ArgumentTuple[0]
)()
if len(__ArgumentTuple[1]['LiargVariablesList']
)==0 and __ArgumentTuple[1]['KwargVariablesDict']==None
else(
SYS.get(
self.FiguredAxesVariable,
__ArgumentTuple[0]
)(**__ArgumentTuple[1]['KwargVariablesDict'])
if len(__ArgumentTuple[1]['LiargVariablesList']
)==0
else(
SYS.get(
self.FiguredAxesVariable,
__ArgumentTuple[0]
)(
*__ArgumentTuple[1]['LiargVariablesList'],
**__ArgumentTuple[1]['KwargVariablesDict']
)
if __ArgumentTuple[1]['KwargVariablesDict']!=None
else
SYS.get(
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)
def do_apply(self):
""" """
#debug
self.debug(
('self.',self,[
'ApplyingMethodVariable',
'ApplyingArgVariable'
])
)
#Check
if type(self.ApplyingArgVariable)!=SYS.ApplyDictClass:
#Check
if self.ApplyingMethodVariable in [
'get','__getitem__','execute'
]:
#Check
if type(self.ApplyingArgVariable)!=list:
self.ApplyingArgVariable=[self.ApplyingArgVariable]
#init
self.ApplyingArgVariable=SYS.ApplyDictClass(
{
'LiargVariablesList':self.ApplyingArgVariable
}
)
#Check
if type(self.ApplyingMethodVariable)!=str:
#Check
if type(self.ApplyingMethodVariable)==SYS.ApplyDictClass:
#apply
self.apply(
self.ApplyingMethodVariable['MethodStr'],
self.ApplyingMethodVariable
)
#return
return
elif hasattr(self.ApplyingMethodVariable,'items'):
#map
map(
lambda __ItemTuple:
self.apply(
__ItemTuple[0],
__ItemTuple[1]
),
self.ApplyingMethodVariable.items()
)
#return
return
elif type(self.ApplyingMethodVariable)==list:
#debug
self.debug(
[
'we do a map top map',
('self.',self,[
'ApplyingMethodVariable',
'ApplyingArgVariable'
])
]
)
#map
self.AppliedMapVariablesList=map(
lambda __MethodVariable,__ArgVariable:
self.apply(
__MethodVariable,
__ArgVariable
),
self.ApplyingMethodVariable,
self.ApplyingArgVariable['LiargVariablesList']
)
#return
return
else:
#Check
if self.ApplyingMethodVariable.startswith(ApplyMapPrefixStr):
#Set
ApplyArgVariable=self.ApplyingArgVariable['LiargVariablesList']
#Check
if hasattr(ApplyArgVariable,'items'):
ApplyArgVariable=ApplyArgVariable.items()
#apply a map to map
self.apply(
[
SYS.deprefix(
self.ApplyingMethodVariable,
ApplyMapPrefixStr
)
]*len(self.ApplyingArgVariable),
ApplyArgVariable
)
#return
return
else:
#set
self.AppliedMethod=getattr(
self,
self.ApplyingMethodVariable
)
#debug
''''
self.debug(
('self.',self,[
'AppliedMethod'
])
)
'''
#Check
if self.AppliedMethod!=None:
#debug
self.debug(
[
'AppliedMethod is good, We are going to apply',
('self.',self,[
'AppliedMethod',
'ApplyingArgVariable'
])
]
)
#Check
if len(self.ApplyingArgVariable['KwargVariablesDict'])>0:
#debug
'''
self.debug('We apply with a KwargVariablesDict')
'''
#Call the AppliedMethod
self.AppliedOutputVariable=self.AppliedMethod(
*self.ApplyingArgVariable['LiargVariablesList'],
**self.ApplyingArgVariable['KwargVariablesDict']
)
else:
#debug
'''
self.debug('We apply without a KwargVariablesDict')
'''
#Call
self.AppliedOutputVariable=self.AppliedMethod(
*self.ApplyingArgVariable['LiargVariablesList']
)
def mimic_set(self):
#debug
'''
self.debug(
('self.',self,[
'SettingKeyVariable',
'SettingValueVariable'
])
)
'''
#Check
if type(self.SettingKeyVariable)==str:
#Check
if self.SettingKeyVariable.startswith(
CommandPrefixStr
):
#debug
'''
self.debug(
'We command here'
)
'''
#deprefix
CommandGetKeyStr=SYS.deprefix(
self.SettingKeyVariable,
CommandPrefixStr
)
#Check
if CommandGetKeyStr.startswith(CommandWalkStr):
#debug
'''
self.debug(
'We command-walk here'
)
'''
#command
self.command(
SYS.deprefix(
CommandGetKeyStr,
CommandWalkStr
),
self.SettingValueVariable,
_AfterWalkRigidBool=True
)
#stop the setting
return {'HookingIsBool':False}
elif CommandGetKeyStr.startswith(CommandSelfStr+CommandWalkStr):
#debug
'''
self.debug(
'We command-self-walk here'
)
'''
#command
self.command(
SYS.deprefix(
CommandGetKeyStr,
CommandSelfStr+CommandWalkStr
),
self.SettingValueVariable,
_AfterWalkRigidBool=True,
_SelfBool=True
)
#stop the setting
return {'HookingIsBool':False}
else:
#command
self.command(
CommandGetKeyStr,
self.SettingValueVariable
)
#stop the setting
return {'HookingIsBool':False}
#Check
elif self.SettingKeyVariable.startswith(
CommandWalkStr
):
#debug
'''
self.debug(
'We walk-command here'
)
'''
CommandGetKeyStr=SYS.deprefix(
self.SettingKeyVariable,
CommandWalkStr
)
#Check
if CommandGetKeyStr.startswith(CommandPrefixStr):
#command
self.command(
SYS.deprefix(
CommandGetKeyStr,
CommandPrefixStr
),
self.SettingValueVariable,
_BeforeWalkRigidBool=True
)
#stop the setting
return {'HookingIsBool':False}
elif CommandGetKeyStr.startswith(CommandSelfStr):
#command
self.command(
SYS.deprefix(
CommandGetKeyStr,
CommandSelfStr+CommandPrefixStr
),
self.SettingValueVariable,
_BeforeWalkRigidBool=True,
_AfterSelfRigidBool=True
)
#stop the setting
return {'HookingIsBool':False}
#Check
elif self.SettingKeyVariable.startswith(
CommandSelfStr+CommandWalkStr+CommandPrefixStr
):
#command
self.command(
SYS.deprefix(
self.SettingKeyVariable,
CommandSelfStr+CommandWalkStr+CommandPrefixStr
),
self.SettingValueVariable,
_BeforeWalkRigidBool=True,
_BeforeSelfRigidBool=True
)
#stop the setting
return {'HookingIsBool':False}
#debug
'''
self.debug(
[
'Call the base set method',
'BaseClass is '+str(BaseClass),
('self.',self,['SettingKeyVariable'])
]
)
'''
#Call the base method
BaseClass.set(self)
def mimic_set(self):
#Check
if type(self.SettingValueVariable
)==str:
#/####################/#
# Case of a call of an execution str
#
#Check
if self.SettingValueVariable.startswith(ExecutionPrefixStr):
#debug
'''
self.debug('we execute here')
'''
#deprefix
ExecutedStr="ExecutedVariable="+SYS.deprefix(
self.SettingValueVariable,
ExecutionPrefixStr
)
#debug
'''
self.debug('ExecutedStr is '+ExecutedStr)
'''
#execute
self.execute(
ExecutedStr
)
#alias
self[self.SettingKeyVariable]=self.ExecutedLocalsDict['ExecutedVariable']
#stop the getting
return {'HookingIsBool':False}
#/####################/#
# Case of a call of a method of a child object
#
#Check
if type(
self.SettingKeyVariable
)==str:
#Check
if ExecutionDotStr in self.SettingKeyVariable:
#debug
'''
self.debug('we get an attribute of the SettingKeyVariable')
'''
#previous
GetKeyStr,AttributeStr=SYS.previous(
self.SettingKeyVariable,
ExecutionDotStr
)
#debug
'''
self.debug(
[
'GetKeyStr is '+GetKeyStr,
'AttributeStr is '+AttributeStr
]
)
'''
#get
GetValueVariable=self[GetKeyStr]
#get the get
AttributeValueVariable=getattr(
GetValueVariable,
AttributeStr
)
#debug
'''
self.debug(
[
'GetValueVariable is '+SYS._str(GetValueVariable),
'AttributeValueVariable is '+SYS._str(AttributeValueVariable),
('self.',self,['SettingValueVariable'])
]
)
'''
#call
if callable(AttributeValueVariable):
#debug
'''
self.debug(
[
'we set call',
('self.',self,['SettingValueVariable']),
'AttributeValueVariable is ',
str(AttributeValueVariable)
]
)
'''
#Check
if type(self.SettingValueVariable)==list and len(
self.SettingValueVariable)>0 and hasattr(self.SettingValueVariable[0],'items'
) and Setter.SetValueLambdaGrabStr in self.SettingValueVariable[0]:
#get
ExecutedMapLambdaList=self.getMapLambdaList(
self.SettingValueVariable[0]
)
#debug
self.debug(
[
'ExecutedMapLambdaList is ',
SYS._str(ExecutedMapLambdaList)
]
)
#set
self[AttributeValueVariable]=[ExecutedMapLambdaList]
else:
#set
self[AttributeValueVariable]=self.SettingValueVariable
#get the method and call it
#AttributeValueVariable(*LiargValueVariable)
else:
#alias
AttributeValueVariable=LiargValueVariable
#stop the setting
return {'HookingIsBool':False}
#Call the parent method
BaseClass.set(self)
def __init__(self,_ArgumentDict=None,_GetterVariable=None): #call the base method collections.OrderedDict.__init__(self) #debug ''' _GetterVariable.debug( [ '_ArgumentDict is ', SYS._str(_ArgumentDict) ] ) ''' #init self['LiargVariablesList']=[] self['KwargVariablesDict']=None """ self['ArgumentDictBool']=any( map( lambda __KeyStr: __KeyStr in _ArgumentDict, [ SetLiargGrabStr, SetMapLiargGetGrabStr, SetLiargGetGrabStr, SetKwargGrabStr, SetMapKwargGetKeyGrabStr, SetMapKwargGetKeyValueGrabStr ] ) ) """ #Check if hasattr(_ArgumentDict,'items'): #/###################/# # Check for #liarg # if SetLiargGrabStr in _ArgumentDict: #debug ''' _GetterVariable.debug( [ 'we itemize with a value with a SetValueGrabStr inside', 'SettedTempLiargSettingValueVariable is '+SYS._str( SettedTempLiargSettingValueVariable) ] ) ''' #set self['LiargVariablesList']=_ArgumentDict[ SetLiargGrabStr ] elif SetMapLiargGetGrabStr in _ArgumentDict: #debug ''' _GetterVariable.debug( [ 'we set a value with a SetMapLiargGetGrabStr inside' ] ) ''' #set self['LiargVariablesList']=_GetterVariable[ SYS.deprefix( SetMapLiargGetGrabStr, SetLiargGrabPrefixStr ) ]( *_ArgumentDict[SetMapLiargGetGrabStr] ).ItemizedMapValueVariablesList #debug ''' _GetterVariable.debug( [ "self['LiargVariablesList'] is ", SYS._str(self['LiargVariablesList']) ] ) ''' #Check elif SetLiargGetGrabStr in _ArgumentDict: #debug _GetterVariable.debug( [ 'we set a value with a SetLiargGetGrabStr inside', '_ArgumentDict[SetLiargGetGrabStr] is ', _ArgumentDict[SetLiargGetGrabStr] ] ) #Get self['LiargVariablesList']=_GetterVariable[ _ArgumentDict[SetLiargGetGrabStr] ] #debug _GetterVariable.debug( [ 'we set a value with a SetLiargGetGrabStr inside', 'self[\'LiargVariablesList\'] is ', str(self['LiargVariablesList']) ] ) #/###################/# # Check for #kwarg # #Check if SetKwargGrabStr in _ArgumentDict: #debug ''' _GetterVariable.debug( [ 'There is a #kwarg here' ] ) ''' #get self['KwargVariablesDict']=_ArgumentDict[ SetKwargGrabStr ] elif SetMapKwargGetKeyGrabStr in _ArgumentDict: #debug ''' _GetterVariable.debug( [ 'we set a value with a map SetMapKwargGetKeyGrabStr inside', ] ) ''' #get get the keys SettedKeyVariablesList=_GetterVariable[ Getter.GetMapStr ]( *_ArgumentDict[SetMapKwargGetKeyGrabStr].keys() ).ItemizedMapValueVariablesList #get the values SettedValueVariablesList=_ArgumentDict[ SetMapKwargGetKeyGrabStr ].values() #set self['KwargVariablesDict']=dict( zip( SettedKeyVariablesList, SettedValueVariablesList ) ) elif SetMapKwargGetValueGrabStr in _ArgumentDict: #debug ''' _GetterVariable.debug( [ 'we set a value with a map SetMapKwargGetValueGrabStr inside', ] ) ''' #get get the keys SettedKeyVariablesList=_ArgumentDict[ SetMapKwargGetValueGrabStr ].keys() #get the values SettedValueVariablesList=_GetterVariable[ Getter.GetMapStr ]( *_ArgumentDict[ SetMapKwargGetValueGrabStr ].values() ).ItemizedMapValueVariablesList #set self['KwargVariablesDict']=dict( zip( SettedKeyVariablesList, SettedValueVariablesList ) ) elif SetMapKwargGetKeyValueGrabStr in _ArgumentDict: #debug ''' _GetterVariable.debug( [ 'we set a value with a map SetMapKwargGetKeyValueGrabStr inside', ] ) ''' #get get the keys SettedKeyVariablesList=_GetterVariable[ Getter.GetMapStr ]( *_ArgumentDict[ SetMapKwargGetKeyValueGrabStr ].keys() ).ItemizedMapValueVariablesList #get the values SettedValueVariablesList=_GetterVariable[ Getter.GetMapStr ]( *_ArgumentDict[ SetMapKwargGetKeyValueGrabStr ].values() ).ItemizedMapValueVariablesList #set self['KwargVariablesDict']=dict( zip( SettedKeyVariablesList, SettedValueVariablesList ) ) else: #Check if _ArgumentDict!="Noarg": #append self['LiargVariablesList'].append(_ArgumentDict)
def mimic_get(self):
#debug
'''
self.debug(
('self.',self,['GettingKeyVariable'])
)
'''
#Check
if type(self.GettingKeyVariable
)==str:
#Check
if self.GettingKeyVariable.startswith(ExecutionPrefixStr):
#deprefix
ExecutedStr="ExecutedVariable="+SYS.deprefix(
self.GettingKeyVariable,
ExecutionPrefixStr
)
#debug
'''
self.debug('ExecutedStr is '+ExecutedStr)
'''
#execute
self.execute(
ExecutedStr
)
#alias
self.GettedValueVariable=self.ExecutedLocalsDict['ExecutedVariable']
#stop the getting
return {'HookingIsBool':False}
elif self.GettingKeyVariable.startswith(
Getter.GetDirectPrefixStr
)==False and ExecutionDotStr in self.GettingKeyVariable:
#debug
'''
self.debug(
[
'we get an attribute of the GettingKeyVariable',
[('self.',self,['GettingKeyVariable'])]
]
)
'''
#previous
GetKeyStr,AttributeStr=SYS.previous(
self.GettingKeyVariable,
ExecutionDotStr
)
#debug
'''
self.debug(
[
'GetKeyStr is '+GetKeyStr,
'AttributeStr is '+AttributeStr,
'self is '+SYS._str(self)
]
)
'''
#get
GetValueVariable=self[GetKeyStr]
#debug
'''
self.debug(
[
'GetValueVariable is '+SYS._str(GetValueVariable)
]
)
'''
#get the get
AttributeValueVariable=getattr(
GetValueVariable,
AttributeStr
)
#debug
'''
self.debug(
[
('self.',self,['GettingKeyVariable']),
'GetValueVariable is '+SYS._str(GetValueVariable),
'AttributeValueVariable is '+SYS._str(AttributeValueVariable)
]
)
'''
#call
if callable(AttributeValueVariable):
#get the method and call it
self.GettedValueVariable=AttributeValueVariable()
else:
#alias
self.GettedValueVariable=AttributeValueVariable
#stop the setting
return {'HookingIsBool':False}
#call the base method
BaseClass.get(self)
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)
def do_itemize(self):
#reset
self.setDone(SYS.ItemizerClass)
#debug
'''
self.debug(
[
'We itemize here',
('self.',self,['ItemizingKeyVariable'])
]
)
'''
#Check
if type(self.ItemizingKeyVariable) in SYS.StrTypesList:
#set
self.ItemizedKeyStr=self.ItemizingKeyVariable
#Check
if self.ItemizingKeyVariable.startswith(ItemMapPrefixStr):
#debug
'''
self.debug(
'It is going to be a map'
)
'''
#deprefix
ItemizedMapMethodStr=SYS.deprefix(
self.ItemizingKeyVariable,
ItemMapPrefixStr
)
#get
ItemizedMapMethod=getattr(
self,
ItemizedMapMethodStr
)
#set
ItemizedMapBool=True
#Check
ItemizedGetMethod=getattr
if self.ItemizingMapGetVariable==None:
ItemizedGetMethod=SYS.getNone
if type(self.ItemizingMapGetVariable)==list:
ItemizedGetMethod=SYS.pick
#define
#def MapMethod(_MapList):
def MapMethod(*_MapLiargVariablesList):
#debug
'''
self.debug(
[
'_MapLiargVariablesList is '+SYS._str(_MapLiargVariablesList),
#'ItemizedMapMethodStr is '+ItemizedMapMethodStr,
#'ItemizedMapMethod is '+str(ItemizedMapMethod),
#'ItemizedMapMethod.im_func is '+str(ItemizedMapMethod.im_func)
]
)
'''
#get
ItemizedMapClass=ItemizedMapMethod.im_func.BaseDoClass
#get
ItemizedMapList=ItemizedMapClass.Module.getMapList(
_MapLiargVariablesList
)
#debug
"""
for __ElementVariable in ItemizedMapList:
#Debug
print('ItemizedMapList is l 119')
print(ItemizedMapList)
print('__ElementVariable is ')
print(__ElementVariable)
print('ItemizedGetMethod is ')
print(ItemizedGetMethod)
print('')
#get
GetVariable=ItemizedGetMethod(
ItemizedMapMethod(
*__ElementVariable
),
self.ItemizingMapGetVariable
)
#Debug
print('GetVariable is ')
print(GetVariable)
print('')
"""
#Debug
'''
self.debug(
[
'ItemizedMapMethod is '+SYS._str(ItemizedMapMethod),
#'self.ItemizedMapMethod.__name__ is '+self.ItemizedMapMethod.__name__,
#'self.__class__.InspectInspectDict[self.ItemizedMapMethod.__name__] is ',
#SYS._str(self.__class__.InspectInspectDict[self.ItemizedMapMethod.__name__])
#'ItemizedMapClass is '+str(ItemizedMapClass),
'ItemizedMapList is '+SYS._str(ItemizedMapList)
]
)
'''
#return
self.ItemizedMapValueVariablesList=map(
lambda __ElementVariable:
ItemizedMapClass.getMapValueVariable(
ItemizedMapMethod(
*__ElementVariable
)
),
ItemizedMapList
)
#return self
return self
#alias
self.ItemizedValueMethod=MapMethod
#return
return
#try
try:
#debug
'''
self.debug(
[
'We find in the InspectMethodDict',
'self.__class__.InspectMethodDict is ',
SYS._str(self.__class__.InspectMethodDict)
]
)
'''
#get
ItemizedValueUnboundMethod=self.__class__.InspectMethodDict[
self.ItemizingKeyVariable
]
#set
self.ItemizedMethodStr=self.ItemizingKeyVariable
#alias
self.ItemizedValueMethod=getattr(
self,
self.ItemizedMethodStr
)
except:
#debug
'''
self.debug(
[
'This is not a method call directly',
]
)
'''
#alias
self.ItemizedValueVariable=self.ItemizingValueVariable
def mimic_set(self):
#debug
'''
self.debug(
('self.',self,[
'SettingKeyVariable',
'SettingValueVariable',
])
)
'''
#Check
if type(self.SettingKeyVariable)==str:
#Check
if self.SettingKeyVariable.startswith(PointToStr):
#debug
'''
self.debug(
'we point just here'
)
'''
#point
self.point(
SYS.deprefix(
self.SettingKeyVariable,
PointToStr
),
self.SettingValueVariable
)
#return
return {'HookingIsBool':False}
elif self.SettingKeyVariable.startswith(PointBackStr):
#debug
'''
self.debug(
'we point back here'
)
'''
#point
self.point(
SYS.deprefix(
self.SettingKeyVariable,
PointBackStr
),
self.SettingValueVariable[0],
_BackSetKeyVariable=self.SettingValueVariable[1],
_BackBool=True
)
#return
return {'HookingIsBool':False}
'''
elif self.SettingKeyVariable.startswith(PointPrefixStr):
#debug
self.debug(
'we set in the encapsulate'
)
#set
SettedValueVariable=self[
self.SettingKeyVariable
]
#alias
SettedValueVariable=self.SettingValueVariable
#return
return {'HookingIsBool':False}
'''
#debug
'''
self.debug(
[
'Call the base set method',
'BaseClass is '+str(BaseClass),
('self.',self,['SettingKeyVariable'])
]
)
'''
#call the base method
return BaseClass.set(self)
def mimic_get(self):
#Definition
OutputDict={'HookingIsBool':True}
#debug
'''
self.debug(
('self.',self,['GettingKeyVariable'])
)
'''
#Check
if self.GettingKeyVariable==ManagementChildPrefixStr:
#debug
'''
self.debug('We get all the children teams')
'''
#return
self.GettedValueVariable=self.ManagementDict
#Stop the getting
return {'HookingIsBool':False}
elif type(
self.GettingKeyVariable
)==str:
#Check
if self.GettingKeyVariable.startswith(
ManagementChildPrefixStr
):
#deprefix
GetKeyStr=SYS.deprefix(
self.GettingKeyVariable,
ManagementChildPrefixStr
)
#Check
if GetKeyStr[0]!='.':
#debug
'''
self.debug(
[
'We manage here',
"SYS.deprefix(self.GettingKeyVariable,ManagementChildPrefixStr) is",
SYS.deprefix(self.GettingKeyVariable,ManagementChildPrefixStr)
]
)
'''
#manage
self.GettedValueVariable=self.manage(
SYS.deprefix(self.GettingKeyVariable,ManagementChildPrefixStr)
).ManagedValueVariable
#debug
'''
self.debug(
[
'Ok we have managed',
('self.',self,['GettedValueVariable'])
]
)
'''
#Stop the getting
return {'HookingIsBool':False}
#Check
else:
#debug
'''
self.debug(
[
'We team here',
('self.',self,['GettingKeyVariable'])
]
)
'''
#team
self.GettedValueVariable=getattr(
self.ManagementDict,
GetKeyStr[1:]
)()
#Stop the setting
return {'HookingIsBool':False}
#Call the parent get method
return BaseClass.get(self)
