def __init__(self, args, refDict):
basePmtr.FilterParameter.__init__(self, args,
refDict) # call base init
self.type = 'pipeLine'
self.doc = lang.docPoPl
self.argTypes = ['list']
self.argNames = [
'filterParameterObjectList: a list of sequential Filter ParameterObjects'
]
self.argDefaults = [[['or', 40], ['ob']]]
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
# will raise exception on error
self.outputFmt = 'num' # declare outputFmt as num by default
self.inputFmt = ['num', 'str'] # declare outputFmt as num by default
from athenaCL.libATH.libPmtr import parameter
self.objArray = []
for argList in self.args[0]:
try:
pmtrObj = parameter.factory(argList, 'filterPmtrObjs')
except error.ParameterObjectSyntaxError as msg:
raise error.ParameterObjectSyntaxError(
'failed sub-parameter: %s' % msg)
self.objArray.append(pmtrObj)
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'markovPulse'
self.doc = lang.docPoMp
self.argTypes = ['str', 'list']
self.argNames = ['transitionString', 'parameterObject: order value']
# note: restringulator can hand commas in braces...
# TODO: accept single value for order value!
self.argDefaults = ['a{3,1,1}b{2,1,1}c{3,2,0}:{a=3|b=4|c=1}',
('c', 0)]
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.markovObj = markov.Transition() # creat obj w/o loading
try:
self.markovObj.loadTransition(self.args[0])
except error.TransitionSyntaxError as e:
raise error.ParameterObjectSyntaxError('Markov transition creation failed: %s' % e)
# will raise error
self.orderObj = self._loadSub(self.args[1], 'genPmtrObjs')
# need to store accumulated values
self.accum = []
# create a dictionary to store pulse objects, w/ string
self.pulseRef = {}
# we only need unique signified; even if more than one symbol refers
# to the same signified, this does not matter
for key in self.markovObj.getSignified():
try:
pulseObj = rhythm.Pulse(key) # let guess pulse type
except error.PulseSyntaxError as e:
raise error.ParameterObjectSyntaxError('failed pulse object definition: %s' % e)
self.pulseRef[key] = pulseObj # store objs
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'rhythmSieve'
self.doc = lang.docPoRs
self.argTypes = [['str', 'num', 'list'], 'num', 'str', 'list',]
self.argNames = ['logicalString', 'sieveLength', 'selectionString',
'parameterObject: Rhythm Generator']
self.argDefaults = ['3|4|5', 60, 'rw', ('l', ((3,1,1),(3,1,1),(3,5,1))),]
self.priority = 9 # rhythm gets top priority
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.currentPulse = None # init value, used in getCurrentRhythm
self.length = abs(int(round(self.args[1])))
self.z = list(range(0, self.length))
try:
self.sieveObj = sieve.Sieve(self.args[0], self.z)
except AttributeError:
raise error.ParameterObjectSyntaxError("incorrect sieve syntax.")
# NOTE: update this to use binary segment
# gets a binary representawtion
self.sieveSeg = self.sieveObj(0, self.z, 'bin')
# set z as list from which selector draws
self.control = self._selectorParser(self.args[2]) # raises exception
# select 1/0 from ginary sieve seg
self.selector = basePmtr.Selector(self.sieveSeg, self.control)
# create a parameter object
self.rthmObj = self._loadSub(self.args[3], 'rthmPmtrObjs')
def _loadMinMax(self, min, max):
'''
>>> a = Parameter([])
>>> post = a._loadMinMax(45, 34)
>>> post[0].type, post[1].type
('constant', 'constant')
>>> post = a._loadMinMax(45, ['ru', 0, 1])
>>> post[0].type, post[1].type
('constant', 'randomUniform')
>>> post = a._loadMinMax(['ru', 0, 1], ['ru', 0, 1])
>>> post[0].type, post[1].type
('randomUniform', 'randomUniform')
'''
if drawer.isNum(min):
minArgs = ('c', min)
elif drawer.isList(min):
minArgs = min
# check max
if drawer.isNum(max):
maxArgs = ('c', max)
elif drawer.isList(max):
maxArgs = max
# create a parameter object
from athenaCL.libATH.libPmtr import parameter
try:
minObj = parameter.factory(minArgs)
except error.ParameterObjectSyntaxError as msg:
raise error.ParameterObjectSyntaxError('failed sub-parameter: %s' % msg)
try:
maxObj = parameter.factory(maxArgs)
except error.ParameterObjectSyntaxError as msg:
raise error.ParameterObjectSyntaxError('failed sub-parameter: %s' % msg)
return minObj, maxObj
def locator(usrStr, libName=None):
"""
libName can be None to permit access to all
>>> post, name = locator('ru')
>>> name == 'RandomUniform'
True
"""
# convert acronum or other into fully named parameter string
if usrStr == None:
raise Exception('got bad usr string')
#print _MOD, 'locator', usrStr, libName
objType = pmtrTypeParser(usrStr, libName) #check type string
# fix case, capitalize lead character:
if objType == None:
raise error.ParameterObjectSyntaxError(
'name error: no parameter named %r' % usrStr)
objType = objType[0].upper() + objType[1:]
modFound = None
# this actually looks through external module files
for mod in pmtrModules: # look through all mods for
reload(mod)
classList = dir(mod)
if objType in classList:
modFound = mod
break
if modFound == None: # failure
raise error.ParameterObjectSyntaxError(
'name error: no parameter named %r' % usrStr)
# return reference to object, and string name of object
# may want to retrun objType first char to lower case?
return modFound, objType
def __init__(self, args, refDict):
basePmtr.FilterParameter.__init__(self, args,
refDict) # call base init
self.type = None
self.argTypes = ['str', 'list']
self.argNames = [
'anchorString', 'parameterObject: operator value generator'
]
self.argDefaults = ['lower', ('wc', 'e', 30, 0, 0, 1)]
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
# will raise exception on error
self.outputFmt = 'num' # declare outputFmt as num by default
self.inputFmt = 'num' # declare outputFmt as num by default
self.anchor = self._anchorParser(self.args[0])
#print _MOD, 'anchor set to', self.anchor
from athenaCL.libATH.libPmtr import parameter
try:
self.pmtrObj = parameter.factory(self.args[1],
['genPmtrObjs', 'rthmPmtrObjs'])
except error.ParameterObjectSyntaxError as msg:
raise error.ParameterObjectSyntaxError('failed sub-parameter: %s' %
msg)
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'gaRhythm'
self.doc = lang.docPoGr
self.argTypes = ['list', 'num', 'num', 'num', 'str', 'num']
self.argNames = ['pulseList', 'crossover', 'mutation', 'elitism',
'selectionString', 'populationSize']
self.argDefaults = [[(3,1,1),(3,1,1),(6,1,1),(6,3,1),(3,1,0)],.70,
.060, 0.01, 'oc', 20]
self.priority = 9 # rhythm gets top priority
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
# args = [rObj, crossoverRate, mutationRate, percentElite]
self.currentPulse = None # init value, used in getCurrentRhythm
self.rObj = rhythm.Rhythm(self.args[0])
# must check rhythm before instantiating genome
if len(self.rObj) <= 2:
msg = 'pulse list error: supply a rhythm of 3 or more pulses'
raise error.ParameterObjectSyntaxError(msg) # report error
# exapnd rhythms without rests
#self.rObj = self._expandRhythm(self.rObj)
self.bpm = 120 # used for initial dur calculations
self.crossoverRate = self.args[1]
self.mutationRate = self.args[2]
self.percentElite = self.args[3]
# get populationi size as last arg
self.popSize = self.args[5]
if self.popSize < 2:
msg = 'population size must be 2 or greater'
raise error.ParameterObjectSyntaxError(msg) # report error
try:
self.genome = genetic.Genome(self.popSize, self.rObj.get('triple'),
rhythm.bpmToBeatTime(self.bpm), self.crossoverRate,
self.mutationRate, self.percentElite)
except ValueError:
self.genome = None # this will return error when args checked
if self.genome == None:
raise error.ParameterObjectSyntaxError('genome failed to be populated.')
self.rObjBundle = [] # stores list of rhythms, by family
self.pulseBundle = [] # stores all pulses as one list
self.rawRhythmBundle = self.genome.gen(40, 1) # 2nd arg makes silent
for rawList in self.rawRhythmBundle:
rObj = rhythm.Rhythm(rawList)
rObj.setSus(.94) # create equal sustain
self.rObjBundle.append(rObj) # list of rhythms
for i in range(0, len(rObj)):
self.pulseBundle.append(rObj[i]) # flat list of pulse objects
# set pulseBundle as list from which selector draws
self.control = self._selectorParser(self.args[4]) # raises exception
self.selector = basePmtr.Selector(self.pulseBundle, self.control)
def _loadSub(self, arg, lib, idStr=''):
from athenaCL.libATH.libPmtr import parameter
try:
obj = parameter.factory(arg, lib)
except error.ParameterObjectSyntaxError as msg:
if idStr == '':
raise error.ParameterObjectSyntaxError('failed sub-parameter: %s' % msg)
else:
raise error.ParameterObjectSyntaxError('failed %s sub-parameter: %s' % (idStr, msg))
return obj
def durToAdsr(tStart,
propAbsSwitch,
dur,
attack,
decay,
sustain,
release,
susScalar,
min=0,
max=1):
"""create an adsr envelope
sustain scalar is a value, w/n the unit interval, of the difference between
min and max
>>> durToAdsr(0, 'absolute', 10, 2, 1, 2, 2, .5)
[[0, 0.0], [2, 1.0], [3, 0.5], [5, 0.5], [7, 0.0], [9.999..., 0.0]]
"""
# will automatically sort min, max
peak = unit.denorm(1, min, max)
nadir = unit.denorm(0, min, max)
susLevel = (peak - nadir) * unit.limit(susScalar)
if propAbsSwitch not in ['absolute', 'proportional']:
raise error.ParameterObjectSyntaxError('incorrect switch')
if propAbsSwitch == 'absolute':
timeUnitDenorm = [attack, decay, sustain, release]
if sum(timeUnitDenorm) > dur: # force proportional
propAbsSwitch = 'proportional'
if propAbsSwitch == 'proportional':
timeUnit = unit.unitNormProportion([attack, decay, sustain, release])
timeUnitDenorm = [x * dur for x in timeUnit]
tEnd = tStart + dur
t = tStart
envelope = []
envelope.append([t, nadir])
t = t + _stepFilter(timeUnitDenorm[0]) # attack
envelope.append([t, peak])
t = t + _stepFilter(timeUnitDenorm[1]) # decay
envelope.append([t, susLevel])
t = t + _stepFilter(timeUnitDenorm[2]) # sustain
envelope.append([t, susLevel])
if propAbsSwitch == 'proportional':
t = tEnd - OFFSET # always measure to end
envelope.append([t, nadir])
else: # absolute
t = t + _stepFilter(timeUnitDenorm[3]) # sustain
envelope.append([t, nadir])
t = tEnd - OFFSET # always measure to end
envelope.append([t, nadir])
return envelope
def __init__(self, args, refDict):
basePmtr.Parameter.__init__(self, args, refDict) # call base init
self.type = 'directorySelect'
self.doc = lang.docPoDs
self.outputFmt = 'str' # declare outputFmt as string
self.argTypes = ['str', 'str', 'str']
self.argNames = [
'directoryFilePath', 'fileExtension', 'selectionString'
]
self.argDefaults = ['.', 'aif', 'rw']
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.dirPath = ''
self.fileExt = '' # can start w/ period or not
self.filePathList = [] # updated on __call__
self.timer = rhythm.Timer() # sets start time
self.dirPath = self.args[0]
self.fileExt = self.args[1]
self.control = self._selectorParser(self.args[2]) # raises exception
# will update in self._updateFileList
# can initialize selector empty, but cannot call empty
self.selector = basePmtr.Selector([], self.control)
self.updatePathList = 1 # force update of path list on init
def __init__(self, args, refDict):
basePmtr.FilterParameter.__init__(self, args,
refDict) # call base init
self.type = 'maskFilter'
self.doc = lang.docPoMf
self.argTypes = ['str', 'list', 'list']
self.argNames = [
'boundaryString: limit, wrap, reflect',
'parameterObject: first boundary',
'parameterObject: second boundary',
]
self.argDefaults = [
'l', ('ws', 'e', 60, 0, .5, 0), ('wc', 'e', 90, 0, .5, 1)
]
self.argDemos = []
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
# will raise exception on error
self.outputFmt = 'num' # declare outputFmt as num by default
self.inputFmt = ['num'] # declare outputFmt as num by default
# will raise exception on error
self.boundaryMethod = self._boundaryParser(self.args[0])
self.boundingPmtrObjA = self._loadSub(self.args[1], 'genPmtrObjs')
self.boundingPmtrObjB = self._loadSub(self.args[2], 'genPmtrObjs')
def __init__(self, args, refDict):
basePmtr.FilterParameter.__init__(self, args,
refDict) # call base init
self.type = 'filterQuantize'
self.doc = lang.docPoFq
self.argTypes = ['list', 'list', 'int', 'list']
self.argNames = [
'parameterObject: grid reference value Generator',
'parameterObject: step width Generator',
'stepCount',
'parameterObject: unit interval measure of quantize pull',
]
self.argDefaults = [('c', 0), ('c', .25), 1, ('c', 1)]
self.argDemos = [[('cg', 'up', 0, 1, .0025), ('bg', 'oc', (.4, .6)), 2,
('bpp', 'e', 'l', ((0, 1), (59, 0), (119, 1)), -3)]]
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
# will raise exception on error
self.outputFmt = 'num' # declare outputFmt as num by default
self.inputFmt = ['num'] # declare outputFmt as num by default
# will raise exception on error
self.gridRefObj = self._loadSub(self.args[0], 'genPmtrObjs')
self.stepGenObj = self._loadSub(self.args[1], 'genPmtrObjs')
self.stepCount = self.args[2]
self.pullObj = self._loadSub(self.args[3], 'genPmtrObjs')
self.quantObj = quantize.Quantizer(self.LOOPLIMIT)
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'pulseTriple'
self.doc = lang.docPoPt
self.argTypes = ['list', 'list', 'list', 'list']
self.argNames = ['parameterObject: pulse divisor',
'parameterObject: pulse multiplier',
'parameterObject: accent value between 0 and 1',
'parameterObject: sustain scalar greater than 0',]
self.argDefaults = [('bg','rc',(6,5,4,3)), ('bg','rc',(1,2,3)),
('bg','rc',(1,1,1,0)), ('ru', .5, 1.5)]
self.argDemos = [[('c',4),('cl','f{s}x{81}y{120}k{2}r{1}w{6}c{-2}',109,0.01,'sr','oc'),('cv','f{s}x{81}y{120}k{2}r{1}w{3}c{8}',109,0.003,'sr',0,1,'oc'),('c',1)],
]
self.priority = 9 # rhythm gets top priority
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if not ok: raise error.ParameterObjectSyntaxError(msg) # report error
self.currentPulse = None # init value, used in getCurrentRhythm
# will raise error
self.divObj = self._loadSub(args[0], 'genPmtrObjs', 'divisor')
self.multObj = self._loadSub(args[1], 'genPmtrObjs', 'multiplier')
self.accObj = self._loadSub(args[2], 'genPmtrObjs', 'accent')
self.susObj = self._loadSub(args[3], 'genPmtrObjs', 'sustain')
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'iterateRhythmWindow'
self.doc = lang.docPoIrw
self.argTypes = ['list', 'list', 'str']
self.argNames = ['parameterObjectList: a list of Rhythm Generators',
'parameterObject: generate or skip control Generator',
'selectionString']
self.argDefaults = [(
('l', ((4,3,1),(4,3,1),(4,2,0),(8,1,1),(4,2,1),(4,2,1)),'oc'),
('cs', ('ru', 1.5, 4)),
),
('bg','rc',(-3,6,-1,15)),
'oc']
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.valueBuffer = [] # values g selected
from athenaCL.libATH.libPmtr import parameter
self.objArray = []
for argList in self.args[0]:
try:
pmtrObj = parameter.factory(argList, 'rthmPmtrObjs')
except error.ParameterObjectSyntaxError, msg:
raise error.ParameterObjectSyntaxError, 'failed sub-parameter: %s' % msg
self.objArray.append(pmtrObj)
def __init__(self, args, refDict):
"""searches a list of directories recursively and finds all files
files named in args are found within these directories
dirs are onlys serached if list of dirs has changed"""
basePmtr.Parameter.__init__(self, args, refDict) # call base init
self.type = None # in subclass
self.outputFmt = 'str' # declare outputFmt as string
self.argTypes = [['list', 'str'], 'str']
self.argNames = ['fileNameList', 'selectionString']
self.argDefaults = [[], 'rc']
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.dirList = [] # used to look for changes
self.filePathList = [] # updated on __call__
self.timer = rhythm.Timer() # sets start time
self.updatePathList = 1 # forces update of paths
# not sure this is functioning
#self.tLastUpdate = 0.0 # time of last file dir update
if drawer.isList(self.args[0]):
self.nameList = self.args[0]
elif drawer.isStr(self.args[0]):
tempList = []
tempList.append(self.args[0])
self.nameList = tuple(tempList)
self.control = self._selectorParser(self.args[1]) # raises exception
# choose names from name list
self.selector = basePmtr.Selector(self.nameList, self.control)
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'markovRhythmAnalysis'
self.doc = lang.docPoMra
self.argTypes = ['list', 'int', 'int', 'list']
self.argNames = ['parameterObject: source Rhythm Generator',
'pulseCount',
'maxAnalysisOrder',
'parameterObject: output order value'
]
self.argDefaults = [('l',
((4,3,1),(4,3,1),(4,2,0),(8,1,1),(4,2,1),(4,2,1)),
'oc'), 12, 2, ('cg','u',0,2,.25)]
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.srcObj = self._loadSub(self.args[0], 'rthmPmtrObjs')
self.pulseCount = self.args[1]
self.maxAnalysisOrder = self.args[2]
self.orderObj = self._loadSub(self.args[3], 'genPmtrObjs')
# need to store accumulated values
self.analysisSeries = []
self.accum = []
# create a dictionary to store pulse objects, w/ string
self.pulseRef = {}
# analysis is done on init
self.markovObj = markov.Transition() # creat obj w/o loading
# this may raise an exception
self._updateAnalysis()
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'iterateRhythmHold'
self.doc = lang.docPoIrh
self.argTypes = ['list', 'list', 'list', 'str']
self.argNames = ['parameterObject: source Rhythm Generator',
'parameterObject: size Generator',
'parameterObject: refresh count Generator',
'selectionString']
self.argDefaults = [('pt',('bg', 'rc', (4,2)),('bg', 'oc', (5,4,3,2,1)),
('c', 1), ('ru', .75, 1.25)),
('bg','rc',[2,3,4]),
('bg','oc',[4,5,6]),'oc']
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.srcObj = self._loadSub(self.args[0], 'rthmPmtrObjs')
self.sizeObj = self._loadSub(self.args[1], 'genPmtrObjs')
self.refreshObj = self._loadSub(self.args[2], 'genPmtrObjs')
self.control = self._selectorParser(self.args[3]) # check control string
self.valueBuffer = [] # collection values selected from
self.eventCount = 0
self.eventCountTotal = 0
self.refreshValue = None
def __init__(self, args, refDict):
basePmtr.RhythmParameter.__init__(self, args, refDict) # call base init
self.type = 'pulseSieve'
self.doc = lang.docPoPs
self.argTypes = [['str', 'num','list'], 'num', 'list', 'str', 'str']
self.argNames = ['logicalString', 'sieveLength', 'pulse',
'selectionString', 'articulationString']
self.argDefaults = ['3|4|5@2', 60, (3,1,1), 'oc', 'a']
self.argDemos = [['3|4|5@2', 60, (4,1,1), 'rc', 's'],
]
self.priority = 9 # rhythm gets top priority
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.currentPulse = None # init value, used in getCurrentRhythm
self.length = abs(int(round(self.args[1])))
self.z = list(range(0, self.length))
try:
self.sieveObj = sieve.Sieve(self.args[0], self.z)
except AttributeError:
raise error.ParameterObjectSyntaxError("incorrect sieve syntax.")
try:
self.pulseObj = rhythm.Pulse(self.args[2])
except error.PulseSyntaxError:
raise error.ParameterObjectSyntaxError("incorrect sieve syntax.")
self.pulseObj.setSus(.94) # no sustain
self.pulseOn = self.pulseObj.copy()
self.pulseOn.setAcc(1) # force on
self.pulseOff = self.pulseObj.copy()
self.pulseOff.setAcc(0) # force off
# gets a list if numbers, like 0,3,4,6,9,10
# interpret as equal dur time points
# get format based on ariticulation
self.articulation = self._articulationParser(self.args[4])
if self.articulation == 'sustain': fmt = 'wid'
elif self.articulation == 'attack': fmt = 'bin'
self.sieveObj.segFmtSet(fmt)
self.sieveSeg = self.sieveObj(0, self.z)
# set z as list from which selector draws
self.control = self._selectorParser(self.args[3]) # raises exception
self.selector = basePmtr.Selector(self.sieveSeg, self.control)
def pmtrTypeParser(typeName, libName='genPmtrObjs'):
"""utility functions for parsing user paramter strings into proper
parameter names. accepts short names and long names, regardless of case
does not raise an error if no match: returns string unmodified
parameters can have the same abbreviation if they are in different libraries
>>> pmtrTypeParser('ru', 'genPmtrObjs')
'randomUniform'
>>> pmtrTypeParser('ru', None)
'randomUniform'
>>> pmtrTypeParser('gr', None)
'gaRhythm'
"""
if typeName == None:
raise Exception('got a type name of none')
#print _MOD, 'pmtrTypeParser', typeName, libName
usrStr = drawer.strScrub(typeName, 'lower')
# get all parameter names in a dictionary
if libName == 'genPmtrObjs':
pmtrNames = genPmtrNames
elif libName == 'rthmPmtrObjs':
pmtrNames = rthmPmtrNames
elif libName == 'textPmtrObjs':
pmtrNames = textPmtrNames
elif libName == 'clonePmtrObjs':
pmtrNames = clonePmtrNames
elif libName == 'filterPmtrObjs':
pmtrNames = filterPmtrNames
elif libName == None:
pmtrNames = allPmtrNames
else:
raise error.ParameterObjectSyntaxError(
'no parameter library named: %r' % libName)
for key in list(pmtrNames.keys()):
className = pmtrNames[key]
if usrStr == key:
return className
elif usrStr == className.lower():
return className
# if not mattched, raise an error
raise error.ParameterObjectSyntaxError('no parameter named %r in %s' %
(usrStr, pmtrLibTitle(libName)))
def __init__(self, args, refDict):
basePmtr.FilterParameter.__init__(self, args,
refDict) # call base init
self.type = None
self.argTypes = ['list']
self.argNames = ['parameterObject: operator value generator']
self.argDefaults = [('ws', 'e', 30, 0, 0, 1)]
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
# will raise exception on error
self.outputFmt = 'num' # declare outputFmt as num by default
self.inputFmt = 'num' # declare outputFmt as num by default
from athenaCL.libATH.libPmtr import parameter
try: # note: can be eithe gen or filter parameter object
self.pmtrObj = parameter.factory(self.args[0],
['genPmtrObjs', 'rthmPmtrObjs'])
except error.ParameterObjectSyntaxError as msg:
raise error.ParameterObjectSyntaxError('failed sub-parameter: %s' %
msg)
def _typeFormatParser(self, usrStr):
"decode control choice strings"
ref = {
'stringQuote' : ['sq',],
'string' : ['str', 's'],
}
usrStr = drawer.selectionParse(usrStr, ref)
if usrStr == None:
selStr = drawer.selectionParseKeyLabel(ref)
raise error.ParameterObjectSyntaxError('bad control value: enter %s.' % selStr)
return usrStr
def _selectLevelMonophonicParser(self, usrStr):
"decode control choice strings"
ref = {
'event' : ['e'],
'set' : ['s'],
}
usrStr = drawer.selectionParse(usrStr, ref)
if usrStr == None:
selStr = drawer.selectionParseKeyLabel(ref)
raise error.ParameterObjectSyntaxError('bad control value: enter %s.' % selStr)
return usrStr
def __init__(self, args, refDict):
basePmtr.StaticParameterTexture.__init__(self, args, refDict)
# arg types exclude name of parameter: just data arg
self.argTypes = ['str',]
self.argNames = ['level: event, frame',]
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
# will raise exception on error
self.args[0] = self._selectLevelFrameParser(self.args[0])
# must call update switches to fill internal dictionary
self._updateSwitches()
def durToTrapezoid(tStart,
propAbsSwitch,
dur,
rampUp,
widthMax,
rampDown,
widthMin,
min=0,
max=1):
"""assume dir of peal is widthOn
will automatically convert to proportion if abs sum extends past dur
this is an trapezoid with only one ramp; may not have complete duration time; always leads on
>>> durToTrapezoid(0, 'absolute', 10, 3, 3, 3, .5)
[[0, 0.0], [3, 1.0], [6, 1.0], [9, 0.0], [9.999..., 0.0]]
"""
# will automatically sort min, max
peak = unit.denorm(1, min, max)
nadir = unit.denorm(0, min, max)
if propAbsSwitch not in ['absolute', 'proportional']:
raise error.ParameterObjectSyntaxError('incorrect switch')
if propAbsSwitch == 'absolute':
timeUnitDenorm = [rampUp, widthMax, rampDown, widthMin]
if sum(timeUnitDenorm) > dur: # force proportional
propAbsSwitch = 'proportional'
if propAbsSwitch == 'proportional':
timeUnit = unit.unitNormProportion(
[rampUp, widthMax, rampDown, widthMin])
timeUnitDenorm = [x * dur for x in timeUnit]
tEnd = tStart + dur
t = tStart
envelope = []
envelope.append([t, nadir])
t = t + _stepFilter(timeUnitDenorm[0]) # ramp
envelope.append([t, peak])
t = t + _stepFilter(timeUnitDenorm[1]) # width
envelope.append([t, peak])
t = t + _stepFilter(timeUnitDenorm[2]) # ramp
envelope.append([t, nadir])
t = tEnd - OFFSET # always measure to end
envelope.append([t, nadir])
return envelope
def _selectRetrogradeParser(self, usrStr):
"decode control choice strings"
ref = {
'off' : ['off', '0'],
'timeInverse' : ['ti', 'tinvers'],
'eventInverse' : ['ei', 'retro'],
}
usrStr = drawer.selectionParse(usrStr, ref)
if usrStr == None:
selStr = drawer.selectionParseKeyLabel(ref)
raise error.ParameterObjectSyntaxError('bad control value: enter %s.' % selStr)
return usrStr
def _selectLevelEventCountParser(self, usrStr):
"decode control choice strings"
ref = {
'texture': ['t', 'text', 'texture'],
'segment': ['s', 'seg', 'segment'],
}
usrStr = drawer.selectionParse(usrStr, ref)
if usrStr == None:
selStr = drawer.selectionParseKeyLabel(ref)
raise error.ParameterObjectSyntaxError(
'bad control value: enter %s.' % selStr)
return usrStr
def _selectDensityPartitionParser(self, usrStr):
"decode control choice strings"
ref = {
'duration': ['d', 'dur'],
'set': ['s'],
}
usrStr = drawer.selectionParse(usrStr, ref)
if usrStr == None:
selStr = drawer.selectionParseKeyLabel(ref)
raise error.ParameterObjectSyntaxError(
'bad control value: enter %s.' % selStr)
return usrStr
def _loadAutoConstantStr(self, arg, ref, lib='genPmtrObjs'):
"""accept a number, a list parameter object, or a string from
within a dfeind string group"""
# ref = {'0' : ['tn', 't', 't n' '0'],
# }
if drawer.isNum(arg):
pmtrArgs = ('c', arg)
elif drawer.isStr(arg):
post = drawer.selectionParse(arg, ref, 0) # autosearch off
if post == None:
raise error.ParameterObjectSyntaxError('no such preset name known.')
pmtrArgs = ('c', post) # a constant pmtr obj
else: # its a list to create a ParameterObject
pmtrArgs = arg
# create a ParameterObject
from athenaCL.libATH.libPmtr import parameter
try:
obj = parameter.factory(pmtrArgs, lib)
except error.ParameterObjectSyntaxError as msg:
raise error.ParameterObjectSyntaxError('failed sub-parameter: %s' % msg)
return obj
def __init__(self, args, refDict):
basePmtr.Parameter.__init__(self, args, refDict) # call base init
self.type = 'constantFile'
self.doc = lang.docPoCf
self.outputFmt = 'str' # declare outputFmt as string
self.argTypes = ['str']
self.argNames = ['absoluteFilePath']
self.argDefaults = [''] # no default possible
# check raw arguments for number, type
ok, msg = self._checkRawArgs()
if ok == 0: raise error.ParameterObjectSyntaxError(msg) # report error
self.filePath = drawer.pathScrub(self.args[0])
def factory(rawArgs, libName=None, refDict=None):
"""this is used only for loading and returning an object
can return obj or parsed args
first thing in list must be a string, type def
libName can be a list or a string
rawArgs is a list of python data types, starting with the po name
exceptions that may be raised: error.ParameterObjectSyntaxError
"""
reload(basePmtr) # reload base class
if not drawer.isList(rawArgs):
rawArgs = eval(drawer.restringulator(rawArgs))
# if only string, we have only one argument, no commas
if drawer.isStr(rawArgs):
rawArgs = [rawArgs]
# old method simply put rawArgs, if a string, as a first argument
# rawArgs = [rawArgs,] # add to a list, could be a single str
# first arg is always a string, naming the parameter type
# obj args could be empty if requires no arguments
objType, objArgs = rawArgs[0], list(rawArgs[1:])
libOpt = [] # option libs
if not drawer.isList(libName):
libOpt.append(libName)
else:
libOpt = libName
for i in range(0, len(libOpt)):
name = libOpt[i]
if name != None: # None is all
name = pmtrLibParser(name) # name of possible library
try: # will raise exception on error
mod, modStr = locator(objType, name) #check type string
except error.ParameterObjectSyntaxError as e:
modStr = None
if modStr == None:
if i != len(libOpt) - 1:
continue # if not the last one to try
else:
raise error.ParameterObjectSyntaxError(
'parameter lib error (%s: %s, %s, %s)' %
(name, objType, modStr, rawArgs))
else: # got a good object
break
# failure
pmtrObjAttr = getattr(mod, modStr)
#print _MOD, 'factory loading object', mod, objType
pmtrObj = pmtrObjAttr(objArgs, refDict)
return pmtrObj