def clickBtnRoot() : # 관리자페이지 로그인
if edtId.get() == 'admin' and edtPw.get() == '1234' :
#messagebox.showerror('성공', '로그인 성공')
print("관리자 페이지 로그인 성공")
window.destroy()
Root.main()
else :
messagebox.showerror('실패', '로그인 실패')
print('로그인 실패')
pass
def getMatplotlibData(self, key):
'''
Get root_numpy data converted into python object most useful for plotting with matplotlib
:param key: ROOT name of object
:return: root object converted to format most useful for plotting with matplotlib
'''
if self._rootType[key] == "TH1":
return _Root.TH1(self.getRootData(key))
elif self._rootType[key] == "TTree":
return _Root.TTree(self.getRootNumpyData(key))
def test_duplicates_indices(self):
self.assertEqual(Root.duplicates_indices(self.testArray),
{"Dan": [0, 4]})
self.assertEqual(Root.duplicates_indices(self.testArray1), {
"Dan": [0, 4],
"Bob": [1, 2]
})
self.assertEqual(Root.duplicates_indices(self.testArray2), {
"Dan": [0, 4],
"Bob": [1, 2, 5],
"Zellinger": [3, 6]
})
def main(argv): a=13; b=9; p=7951; output='Order\t'; bigOrder=1; for x in range(0,p): root=Root.findRoot(x,a,b,p); if root!='NOT_A_ROOT': root1=(x,root[0]); root2=(x,root[1]); res=(); order=Order.findOrder(root1,a,p); output = str(order)+'\t1-'+str(root1)+' '; if bigOrder< order: bigOrder=order; res=root1; #R=Addition.doubleP(root1,a,p); #output=output+'2-'+str(R)+' '; #for i in range(3,order): # R=Addition.addP(root1,R,a,p); # output=output+str(i)+'-'+str(R)+' '; #print output; order=Order.findOrder(root2,a,p); if bigOrder< order: bigOrder=order; res=root2; output = str(order)+'\t1-'+str(root2)+' '; #print output; print bigOrder, res;
def do(self, configuration, arguments):
#
# Parameters setup
#
Command.add_option(self,
"-f",
"--force",
action="store_true",
dest="force",
help="force operation")
Command.add_option(self,
"-n",
"--name",
action="store",
dest="name",
help="specify root node name")
(opts, args) = Command.parse_args(self, arguments)
if (len(args) > 0):
raise Exceptions.UnknownParameter(args[0])
if (opts.name != None):
name = opts.name
else:
name = configuration.get(self.name, 'name', str,
"Nameless " + PROGRAM_NAME + " database")
assert (isinstance(name, str))
db_file = configuration.get(PROGRAM_NAME, 'database', str)
assert (db_file != None)
if (opts.force is not True):
debug("Force mode disabled")
assert (db_file != None)
if (os.path.isfile(db_file)):
raise Exceptions.ForceNeeded("database file "
"`" + db_file + "' "
"already exists")
#
# Work
#
# We are in force mode (which means we must write the DB whatsover)
# or the DB file is not present at all ...
db = DB.Database()
# Create an empty tree
tree = Root.Root(name)
assert (tree != None)
#
# Save database back to file
#
db.save(db_file, tree)
debug("Success")
def with_busy_cursor(thunk):
"""
Execute the thunk with the cursor changed to a watch.
"""
root = Root.get_root()
# Traverse widget hierarchy changing all custom cursors
# to watches. Remember what to change back afterwards.
changed = []
for toplevel in root.children.values():
install_watches(toplevel, changed, 1)
toplevel.update()
try:
thunk()
finally:
for widget, old_cursor in changed:
try:
widget.configure(cursor=old_cursor)
except:
pass
def make2DHistogram(self,
command,
selector="",
name="hist",
title="hist",
xnbins=-1,
xlow=-1.,
xhigh=1.,
ynbins=-1,
ylow=-1.,
yhigh=1.):
'''
Use TTree.Draw to create a histogram, useful when the size of the data cannot be extracted using getNumpyBranch
:param command:
:param selector:
:param name: histogram name
:param title: histogram title
:param xnbins: x number of bins
:param xlow: x histogram lowest edge
:param xhigh: x histogram highest edge
:param ynbins: y number of bins
:param ylow: y histogram lowest edge
:param yhigh: y histogram highest edge
:return: Root.TH1 object
'''
# just in case
_ROOT.TH2.AddDirectory(True)
# check for existing histogram
h = _ROOT.gDirectory.Get(name)
if h != None:
_ROOT.gDirectory.Delete(name)
# make histogram if bins are defined
if xnbins != -1 and ynbins != -1:
h = _ROOT.TH2D(name, title, xnbins, xlow, xhigh, ynbins, ylow,
yhigh)
nSelected = self._tree.Draw(command + " >> " + name, selector, "goff")
rootH = _gDirectory.Get(name) # root histogram object
maplH = _Root.TH2(rootH) # matplotlib histogram object
return maplH
def main():
tk = Root.create_root()
args = sys.argv[1:]
if args:
cwd = os.getcwd()
for arg in args:
path = os.path.normpath(os.path.join(cwd, arg))
if debug_cmd_line_args:
print "main:"
print "...cwd =", cwd
print "...arg =", arg
print "...path =", path
try:
open_project_file(path)
except Errors.Cancelled:
pass
except:
if debug_cmd_line_args:
print "Exception processing command line arg"
Errors.report_exception(sys.exc_type, sys.exc_value, sys.exc_traceback)
else:
new_project()
tk.mainloop()
def test_duplicates(self):
self.assertEqual(Root.duplicates(self.testArray), ["Dan"])
self.assertEqual(Root.duplicates(self.testArray1), ["Dan", "Bob"])
self.assertEqual(Root.duplicates(self.testArray2),
["Dan", "Bob", "Zellinger"])
def test_sortDictResult(self):
self.assertIsNone(Root.sortDictResult(self.dict))
def test_timeOperation(self):
result = Root.timeOperation(self.timesAA)
self.assertEqual(result, [1800.0, 1200.0, 4500.0])
def Main():
VideoDeviceNumber = 0
CamList, CamDict = RefreshCamList(
) #this will update the list of new devices ,if any new is connected
MainWindow = Root(VideoDeviceNumber, CamList, CamDict)
MainWindow.CreateMainWindow()
class Player(Repeatable):
# Set private values
__vars = []
__init = False
# These are used by FoxDot
keywords = ('degree', 'oct', 'freq', 'dur', 'delay', 'blur', 'amplify',
'scale', 'bpm', 'sample')
# Base attributes
base_attributes = ('sus', 'fmod', 'vib', 'slide', 'slidefrom', 'pan',
'rate', 'amp', 'room', 'buf', 'bits')
play_attributes = ('scrub', 'cut')
fx_attributes = FxList.kwargs()
metro = None
server = None
# Tkinter Window
widget = None
default_scale = Scale.default()
default_root = Root.default()
def __init__(self):
# Inherit
Repeatable.__init__(self)
# General setup
self.synthdef = None
self.id = None
self.quantise = False
self.stopping = False
self.stop_point = 0
self.following = None
self.queue_block = None
self.playstring = ""
self.buf_delay = []
# Visual feedback information
self.envelope = None
self.line_number = None
self.whitespace = None
self.bang_kwargs = {}
# Modifiers
self.reversing = False
self.degrading = False
# Keeps track of which note to play etc
self.event_index = 0
self.event_n = 0
self.notes_played = 0
self.event = {}
# Used for checking clock updates
self.old_dur = None
self.old_pattern_dur = None
self.isplaying = False
self.isAlive = True
# These dicts contain the attribute and modifier values that are sent to SuperCollider
self.attr = {}
self.modf = {}
# Keyword arguments that are used internally
self.scale = None
self.offset = 0
# List the internal variables we don't want to send to SuperCollider
self.__vars = self.__dict__.keys()
self.__init = True
self.reset()
# Class methods
@classmethod
def Attributes(cls):
return cls.keywords + cls.base_attributes + cls.fx_attributes + cls.play_attributes
# Player Object Manipulation
def __rshift__(self, other):
""" The PlayerObject Method >> """
if isinstance(other, SynthDefProxy):
self.update(other.name, other.degree, **other.kwargs)
self + other.mod
for method, arguments in other.methods.items():
args, kwargs = arguments
getattr(self, method).__call__(*args, **kwargs)
return self
raise TypeError(
"{} is an innapropriate argument type for PlayerObject".format(
other))
return self
def __setattr__(self, name, value):
if self.__init:
# Force the data into a TimeVar or Pattern if the attribute is used with SuperCollider
if name not in self.__vars:
value = asStream(value) if not isinstance(
value, (PlayerKey, TimeVar.var)) else value
# Update the attribute dict
self.attr[name] = value
# Update the current event
self.event[name] = modi(value, self.event_index)
return
self.__dict__[name] = value
return
def __eq__(self, other):
return self is other
def __ne__(self, other):
return not self is other
# --- Startup methods
def reset(self):
# --- SuperCollider Keywords
# Left-Right panning (-1,1)
self.pan = 0
# Sustain and blur (aka legato)
self.sus = 1
# Amplitude
self.amp = 1
# Rate - varies between SynthDef
self.rate = 1
# Audio sample buffer number
self.buf = 0
# Reverb
self.verb = 0.05
self.room = 0.01
# Frequency modifier
self.fmod = 0
# Buffer
self.sample = 0
# --- FoxDot Keywords
# Duration of notes
self.dur = 0.5 if self.synthdef == SamplePlayer else 1
self.old_pattern_dur = self.old_dur = self.attr['dur']
self.delay = 0
# Degree of scale / Characters of samples
self.degree = " " if self.synthdef is SamplePlayer else 0
# Octave of the note
self.oct = 5
# Amplitude mod
self.amplify = 1
# Legato
self.blur = 1
# Tempo
self.bpm = None
# Frequency and modifier
self.freq = 0
# Offbeat delay
self.offset = 0
self.modf = dict([(key, [0]) for key in self.attr])
return self
# --- Update methods
def __call__(self, **kwargs):
# If stopping, kill the event
if self.stopping and self.metro.now() >= self.stop_point:
self.kill()
return
# If the duration has changed, work out where the internal markers should be
if self.dur_updated():
self.event_n, self.event_index = self.count()
self.old_dur = self.attr['dur']
# Get the current state
dur = 0
while True:
self.get_event()
dur = float(self.event['dur'])
if dur == 0:
self.event_n += 1
else:
break
# Play the note
if self.metro.solo == self and kwargs.get(
'verbose', True) and type(self.event['dur']) != rest:
self.freq = 0 if self.synthdef == SamplePlayer else self.calculate_freq(
)
self.send()
# If using custom bpm
if self.event['bpm'] is not None:
dur *= (float(self.metro.bpm) / float(self.event['bpm']))
# Schedule the next event
self.event_index = self.event_index + dur
self.metro.schedule(self, self.event_index, kwargs={})
# Change internal marker
self.event_n += 1 if not self.reversing else -1
self.notes_played += 1
return
def count(self, time=None):
# Count the events that should have taken place between 0 and now()
n = 0
acc = 0
dur = 0
now = time if time is not None else self.metro.now()
durations = self.rhythm()
total_dur = float(sum(durations))
if total_dur == 0:
WarningMsg("Player object has a total duration of 0. Set to 1")
self.dur = total_dur = durations = 1
acc = now - (now % total_dur)
try:
n = int(len(durations) * (acc / total_dur))
except TypeError as e:
WarningMsg(e)
self.stop()
return 0, 0
while True:
dur = float(modi(durations, n))
if acc + dur > now:
break
else:
acc += dur
n += 1
# Store duration times
self.old_dur = self.attr['dur']
# Returns value for self.event_n and self.event_index
self.notes_played = n
return n, acc
def update(self, synthdef, degree, **kwargs):
# SynthDef name
self.synthdef = synthdef
if self.isplaying is False:
self.reset()
# If there is a designated solo player when updating, add this at next bar
if self.metro.solo.active() and self.metro.solo != self:
self.metro.schedule(lambda: self.metro.solo.add(self),
self.metro.next_bar() - 0.001)
# Update the attribute values
special_cases = ["scale", "root", "dur"]
# Set the degree
if synthdef is SamplePlayer:
self.playstring = degree
setattr(self, "degree", degree if len(degree) > 0 else " ")
elif degree is not None:
self.playstring = str(degree)
setattr(self, "degree", degree)
# Set special case attributes
self.scale = kwargs.get("scale", self.__class__.default_scale)
self.root = kwargs.get("root", self.__class__.default_root)
# If only duration is specified, set sustain to that value also
if "dur" in kwargs:
self.dur = kwargs['dur']
if "sus" not in kwargs and synthdef != SamplePlayer:
self.sus = self.attr['dur']
if synthdef is SamplePlayer: pass
# self.old_pattern_dur
# self.old_dur = self.attr['dur']
# Set any other attributes
for name, value in kwargs.items():
if name not in special_cases:
setattr(self, name, value)
# Calculate new position if not already playing
if self.isplaying is False:
# Add to clock
self.isplaying = True
self.stopping = False
self.event_index = self.metro.next_bar()
self.event_n = 0
self.event_n, _ = self.count(self.event_index)
self.metro.schedule(self, self.event_index)
return self
def dur_updated(self):
dur_updated = self.attr['dur'] != self.old_dur
if self.synthdef == SamplePlayer:
dur_updated = (self.pattern_rhythm_updated() or dur_updated)
return dur_updated
def step_duration(self):
return 0.5 if self.synthdef is SamplePlayer else 1
def rhythm(self):
# If a Pattern TimeVar
if isinstance(self.attr['dur'], TimeVar.Pvar):
r = asStream(self.attr['dur'].now().data)
# If duration is a TimeVar
elif isinstance(self.attr['dur'], TimeVar.var):
r = asStream(self.attr['dur'].now())
else:
r = asStream(self.attr['dur'])
# TODO: Make sure degree is a string
if self.synthdef is SamplePlayer:
try:
d = self.attr['degree'].now()
except:
d = self.attr['degree']
r = r * [(char.dur if hasattr(char, "dur") else 1)
for char in d.flat()]
return r
def pattern_rhythm_updated(self):
r = self.rhythm()
if self.old_pattern_dur != r:
self.old_pattern_dur = r
return True
return False
def char(self, other=None):
if other is not None:
try:
if type(other) == str and len(other) == 1: #char
return BufferManager.bufnum(self.now('buf')) == other
raise TypeError("Argument should be a one character string")
except:
return False
else:
try:
return BufferManager.bufnum(self.now('buf'))
except:
return None
def calculate_freq(self):
""" Uses the scale, octave, and degree to calculate the frequency values to send to SuperCollider """
# If the scale is frequency only, just return the degree
if self.scale == Scale.freq:
try:
return list(self.event['degree'])
except:
return [self.event['degree']]
now = {}
for attr in ('degree', 'oct'):
now[attr] = self.event[attr]
try:
now[attr] = list(now[attr])
except:
now[attr] = [now[attr]]
size = max(len(now['oct']), len(now['degree']))
f = []
for i in range(size):
try:
midinum = midi(self.scale, modi(now['oct'], i),
modi(now['degree'], i), self.now('root'))
except:
WarningMsg(
"Invalid degree / octave arguments for frequency calculation, reset to default"
)
raise
f.append(miditofreq(midinum))
return f
def f(self, *data):
""" adds value to frequency modifier """
self.fmod = tuple(data)
p = []
for val in self.attr['fmod']:
try:
pan = tuple((item / ((len(val) - 1) / 2.0)) - 1
for item in range(len(val)))
except:
pan = 0
p.append(pan)
self.pan = p
return self
# Methods affecting other players - every n times, do a random thing?
def stutter(self, n=2, **kwargs):
""" Plays the current note n-1 times over the current durations """
if self.metro.solo == self and n > 0:
dur = float(kwargs.get("dur", self.event['dur'])) / int(n)
delay = 0
for stutter in range(1, n):
delay += dur
sub = {
kw: modi(val, stutter - 1)
for kw, val in kwargs.items()
}
self.metro.schedule(func_delay(self.send, **sub),
self.event_index + delay)
return self
# --- Misc. Standard Object methods
def __int__(self):
return int(self.now('degree'))
def __float__(self):
return float(self.now('degree'))
def __add__(self, data):
""" Change the degree modifier stream """
self.modf['degree'] = asStream(data)
return self
def __sub__(self, data):
""" Change the degree modifier stream """
data = asStream(data)
data = [d * -1 for d in data]
self.modf['degree'] = data
return self
def __mul__(self, data):
""" Multiplying an instrument player multiplies each amp value by
the input, or circularly if the input is a list. The input is
stored here and calculated at the update stage """
if type(data) in (int, float):
data = [data]
self.modf['amp'] = asStream(data)
return self
def __div__(self, data):
if type(data) in (int, float):
data = [data]
self.modf['amp'] = [1.0 / d for d in data]
return self
# --- Data methods
def largest_attribute(self):
""" Returns the length of the largest nested tuple in the attr dict """
# exclude = 'degree' if self.synthdef is SamplePlayer else None
exclude = None
size = len(self.attr['freq'])
for attr, value in self.event.items():
if attr != exclude:
try:
l = len(value)
if l > size:
size = l
except:
pass
return size
# --- Methods for preparing and sending OSC messages to SuperCollider
def now(self, attr="degree", x=0):
""" Calculates the values for each attr to send to the server at the current clock time """
modifier_event_n = self.event_n
attr_value = self.attr[attr]
attr_value = modi(asStream(attr_value), self.event_n + x)
## If this player is following another, update that player first
if attr == "degree" and self.following != None:
if self.following in self.queue_block.objects():
self.queue_block.call(self.following, self)
# If the attribute isn't in the modf dictionary, default to 0
try:
modf_value = modi(self.modf[attr], modifier_event_n + x)
except:
modf_value = 0
# If any values are time-dependant, get the now values
try:
attr_value = attr_value.now()
except:
pass
try:
modf_value = modf_value.now()
except:
pass
# Combine attribute and modifier values
try:
## if attr == "dur" and type(attr_value) == rest:
##
## value = rest(attr_value + modf_value)
##
## else:
value = attr_value + modf_value
except:
value = attr_value
return value
def get_event(self):
""" Returns a dictionary of attr -> now values """
# Get the current event
self.event = {}
attributes = copy(self.attr)
for key in attributes:
# Eg. sp.sus returns the currently used value for sustain
self.event[key] = self.now(key)
# Make sure the object's dict uses PlayerKey instances
if key not in self.__dict__:
self.__dict__[key] = PlayerKey(self.event[key])
elif not isinstance(self.__dict__[key], PlayerKey):
self.__dict__[key] = PlayerKey(self.event[key])
else:
self.__dict__[key].update(self.event[key])
# Special case: sample player
if self.synthdef == SamplePlayer:
try:
event_dur = self.event['dur']
if isinstance(self.event['degree'], PlayGroup):
buf_list = ((0, self.event['degree']), )
event_buf = [0]
else:
buf_list = enumerate(self.event['degree'])
event_buf = list(range(len(self.event['degree'])))
self.buf_delay = []
for i, bufchar in buf_list:
if isinstance(bufchar, PlayGroup):
char = BufferManager[bufchar[0]]
# Get the buffer number to play
buf_mod_index = modi(self.event['sample'], i)
event_buf[i] = char.bufnum(buf_mod_index).bufnum
delay = 0
for n, b in enumerate(bufchar[1:]):
char = BufferManager[b]
buf_mod_index = modi(self.event['sample'], i)
delay += (bufchar[n].dur * self.event['dur'])
self.buf_delay.append(
(char.bufnum(buf_mod_index), delay))
else:
char = BufferManager[bufchar]
# Get the buffer number to play
buf_mod_index = modi(self.event['sample'], i)
event_buf[i] = char.bufnum(buf_mod_index).bufnum
self.event['buf'] = P(event_buf)
except TypeError:
pass
return self
def osc_message(self, index=0, **kwargs):
""" NEW: Creates an OSC packet to play a SynthDef in SuperCollider,
use kwargs to force values in the packet, e.g. pan=1 will force ['pan', 1] """
freq = float(modi(self.attr['freq'], index))
message = ['freq', freq]
fx_dict = {}
attributes = self.attr.copy()
# Go through the attr dictionary and add kwargs
for key in attributes:
try:
# Don't use fx keywords or foxdot keywords
if key not in FxList.kwargs() and key not in self.keywords:
val = modi(kwargs.get(key, self.event[key]), index)
# Special case modulation
if key == "sus":
val = val * self.metro.beat() * modi(
kwargs.get('blur', self.event['blur']), index)
elif key == "amp":
val = val * modi(
kwargs.get('amplify', self.event['amplify']),
index)
message += [key, float(val)]
except:
print("Issue in OSC message for '{}'. Problem with {}".format(
self.synthdef, key))
# See if any fx_attributes
for key in self.fx_attributes:
if key in attributes:
# All effects use sustain to release nodes
fx_dict[key] = []
# Look for any other attributes require e.g. room and verb
for sub_key in FxList[key].args:
if sub_key in self.event:
val = float(
modi(kwargs.get(sub_key, self.event[sub_key]),
index))
# Don't send fx with zero values
if val == 0:
del fx_dict[key]
break
else:
fx_dict[key] += [sub_key, val]
return message, fx_dict
def send(self, **kwargs):
""" Sends the current event data to SuperCollder.
Use kwargs to overide values in the """
size = self.largest_attribute()
banged = False
sent_messages = []
delayed_messages = []
for i in range(size):
osc_msg, effects = self.osc_message(i, **kwargs)
delay = modi(kwargs.get('delay', self.event['delay']), i)
buf = modi(kwargs.get('buf', self.event['buf']), i)
amp = osc_msg[osc_msg.index('amp') + 1]
# Any messages with zero amps or 0 buf are not sent
if (self.synthdef != SamplePlayer
and amp > 0) or (self.synthdef == SamplePlayer and buf > 0
and amp > 0):
if self.synthdef == SamplePlayer:
numChannels = BufferManager.getBuffer(buf).channels
if numChannels == 1:
synthdef = "play1"
else:
synthdef = "play2"
else:
synthdef = str(self.synthdef)
if delay > 0:
if (delay, osc_msg, effects) not in delayed_messages:
self.metro.schedule(
send_delay(self, synthdef, osc_msg, effects),
self.event_index + delay)
delayed_messages.append((delay, osc_msg, effects))
if self.bang_kwargs:
self.metro.schedule(self.bang,
self.metro.now() + delay)
else:
# Don't send duplicate messages
if (osc_msg, effects) not in sent_messages:
self.server.sendPlayerMessage(synthdef, osc_msg,
effects)
sent_messages.append((osc_msg, effects))
if not banged and self.bang_kwargs:
self.bang()
banged = True
if self.buf_delay:
for buf_num, buf_delay in self.buf_delay:
# Only send messages with amps > 0
i = osc_msg.index('amp') + 1
if osc_msg[i] > 0:
# Make sure we use an integer number
buf_num = int(buf_num)
if buf_num > 0:
i = osc_msg.index('buf') + 1
osc_msg[i] = buf_num
numChannels = BufferManager.getBuffer(
buf_num).channels
if numChannels == 1:
synthdef = "play1"
else:
synthdef = "play2"
if (buf_delay + delay, osc_msg,
effects) not in delayed_messages:
self.metro.schedule(
send_delay(self, synthdef, osc_msg,
effects),
self.event_index + buf_delay + delay)
delayed_messages.append(
(buf_delay + delay, osc_msg, effects))
return
#: Methods for stop/starting players
def kill(self):
""" Removes this object from the Clock and resets itself"""
self.isplaying = False
self.repeat_events = {}
self.reset()
return
def stop(self, N=0):
""" Removes the player from the Tempo clock and changes its internal
playing state to False in N bars time
- When N is 0 it stops immediately"""
self.stopping = True
self.stop_point = self.metro.now()
if N > 0:
self.stop_point += self.metro.next_bar() + (
(N - 1) * self.metro.bar_length())
else:
self.kill()
return self
def pause(self):
self.isplaying = False
return self
def play(self):
self.isplaying = True
self.stopping = False
self.isAlive = True
self.__call__()
return self
def follow(self, lead, follow=True):
""" Takes a now object and then follows the notes """
self.degree = lead.degree
self.following = lead
return self
def solo(self, arg=True):
if arg:
self.metro.solo.set(self)
else:
self.metro.solo.reset()
return self
def num_key_references(self):
""" Returns the number of 'references' for the
attr which references the most other players """
num = 0
for attr in self.attr.values():
if isinstance(attr, PlayerKey):
if attr.num_ref > num:
num = attr.num_ref
return num
"""
State-Shift Methods
--------------
These methods are used in conjunction with Patterns.Feeders functions.
They change the state of the Player Object and return the object.
See 'Player.Feeders' for more info on how to use
"""
def lshift(self, n=1):
self.event_n -= (n + 1)
return self
def rshift(self, n=1):
self.event_n += n
return self
def reverse(self):
""" Sets flag to reverse streams """
self.reversing = not self.reversing
if self.reversing:
self.event_n -= 1
else:
self.event_n += 1
return self
def shuffle(self):
""" Shuffles the degree of a player. If possible, do it visually """
if self.synthdef == SamplePlayer:
self._replace_string(PlayString(self.playstring).shuffle())
else:
self._replace_degree(self.attr['degree'].shuffle())
# self.degree = self.attr['degree'].shuffle()
return self
def mirror(self):
if self.synthdef == SamplePlayer:
self._replace_string(PlayString(self.playstring).mirror())
else:
self._replace_degree(self.attr['degree'].mirror())
# self.degree = self.attr['degree'].mirror()
return self
def rotate(self, n=1):
if self.synthdef == SamplePlayer:
self._replace_string(PlayString(self.playstring).rotate(n))
else:
self._replace_degree(self.attr['degree'].rotate(n))
# self.degree = self.attr['degree'].rotate(n)
return self
def _replace_string(self, new_string):
# Update the GUI if possible
if self.widget:
# Replace old_string with new string
self.widget.addTask(target=self.widget.replace,
args=(self.line_number, self.playstring,
new_string))
self.playstring = new_string
setattr(self, 'degree', new_string)
return
def _replace_degree(self, new_degree):
# Update the GUI if possible
if self.widget:
# Replace old_string with new string
self.widget.addTask(target=self.widget.replace_re,
args=(self.line_number, ),
kwargs={'new': str(new_degree)})
self.playstring = str(new_degree)
setattr(self, 'degree', new_degree)
return
def multiply(self, n=2):
self.attr['degree'] = self.attr['degree'] * n
return self
def degrade(self, amount=0.5):
""" Sets the amp modifier to a random array of 0s and 1s
amount=0.5 weights the array to equal numbers """
if not self.degrading:
self.amp = Pwrand([0, 1], [1 - amount, amount])
self.degrading = True
else:
ones = int(self.amp.count(1) * amount)
zero = self.amp.count(0)
self.amp = Pshuf(Pstutter([1, 0], [ones, zero]))
return self
def changeSynth(self, list_of_synthdefs):
new_synth = choice(list_of_synthdefs)
if isinstance(new_synth, SynthDef):
new_synth = str(new_synth.name)
self.synthdef = new_synth
# TODO, change the >> name
return self
"""
Modifier Methods
----------------
Other modifiers for affecting the playback of Players
"""
def offbeat(self, dur=0.5):
""" Off sets the next event occurence """
self.attr['delay'] += (dur - self.offset)
self.offset = dur
return self
def strum(self, dur=0.025):
""" Adds a delay to a Synth Envelope """
x = self.largest_attribute()
if x > 1:
self.delay = asStream([tuple(a * dur for a in range(x))])
else:
self.delay = asStream(dur)
return self
def __repr__(self):
return "a '%s' Player Object" % self.synthdef
def info(self):
s = "Player Instance using '%s' \n\n" % self.synthdef
s += "ATTRIBUTES\n"
s += "----------\n\n"
for attr, val in self.attr.items():
s += "\t{}\t:{}\n".format(attr, val)
return s
def bang(self, **kwargs):
"""
Triggered when sendNote is called. Responsible for any
action to be triggered by a note being played. Default action
is underline the player
"""
if kwargs:
self.bang_kwargs = kwargs
elif self.bang_kwargs:
print self.bang_kwargs
bang = Bang(self, self.bang_kwargs)
return self
def test_lineOperation(self):
file = open('test1.txt', "r")
#linebyline = "Alex: 41 miles @ 34 mph", "Dan: 39 miles @ 47 mph", "Bob: 0 miles"
self.assertEqual(Root.lineOperation(file), 'None')
def test_peopleWithZeroMiles(self):
self.assertEqual(
Root.peopleWithZeroMiles(self.testArray, self.testArray1),
['Alex'])
def main(net):
my_interfaces = net.interfaces(
) # gets a list of interfaces on this router
mymacs = [intf.ethaddr for intf in my_interfaces
] # gets the ethernet addresses for every interface
cache = lruCache(5)
myId, myMAC, myName = findMyId(my_interfaces)
root = Root(myId, myMAC, 0, myName)
log_debug("My ID = {} root {}".format(myId, root.rootMAC))
#sendSTP(root, my_interfaces, net) # flood to nodes
emitSTP(root, myMAC, myId, my_interfaces, net)
forwardTable = {}
# dictionary of interface:forward
for intf in my_interfaces:
forwardTable[intf.name] = True
while True:
try:
timestamp, input_port, packet = net.recv_packet()
except NoPackets:
continue
except Shutdown:
return
# src and dest are mac addresses
# input_port appears to be the name of the port
#add src and input port pair to cache
newSrc = lruEntry(packet[0].src, input_port)
cache.print()
cache.push(newSrc)
log_debug("In {} received packet {} on {}".format(
net.name, packet, input_port))
if packet.has_header(SpanningTreeMessage): #STP packet
msg = SpanningTreeMessage()
msg.from_bytes(packet[1].to_bytes())
log_debug(
"Spanning Tree Message found with root {} {}, current root is {} {} on {}"
.format(msg.root, msg.hops_to_root, root.rootMAC, root.hops,
root.srcPort))
# log_debug("||||||||||||||||||| msg {} root {}".format(msg.root), root.rootMAC())
if ethToId(msg.root) < root.rootID:
log_debug(
"Spanning Tree Message root was less than current root")
root = Root(ethToId(msg.root), msg.root, msg.hops_to_root + 1,
input_port)
forwardTable[input_port] = True
sendSTP(root, myMAC, my_interfaces, net, input_port)
elif ethToId(msg.root
) == root.rootID and msg.hops_to_root + 1 < root.hops:
log_debug(
"Spanning Tree Message root was same as current but shorter distance found"
)
forwardTable[input_port] = True
root.hops = msg.hops_to_root + 1
root.srcPort = input_port
sendSTP(root, myMAC, my_interfaces, net, input_port)
elif input_port != root.srcPort and msg.hops_to_root + 1 == root.hops:
log_debug(
"Spanning Tree Message different roots but same distance, blocking {}"
.format(input_port))
forwardTable[input_port] = False
elif packet[0].dst in mymacs:
log_debug("Packet intended for me")
elif cache.contains(packet[0].dst):
log_debug("Packet destination in LRU cache")
dstPort = cache.getPort(packet[0].dst)
for intf in my_interfaces:
if dstPort == intf.name:
log_debug("Sending packet {} to {}".format(
packet, intf.name))
#log_debug("Packet destination in LRU cache")
dstPort = cache.getPort(packet[0].dst)
for intf in my_interfaces:
if dstPort == intf.name:
#log_debug("Sending packet {} to {}".format(packet, intf.name))
net.send_packet(intf.name, packet)
else: # broadcast
for intf in my_interfaces:
log_debug(intf.name + " " + str(forwardTable[intf.name]))
if input_port != intf.name and forwardTable[intf.name]:
log_debug("Flooding packet {} to {}".format(
packet, intf.name))
net.send_packet(intf.name, packet)
net.shutdown()
if __name__ == "__main__":
#if not os.path.exists(pipe_name):
# os.mkfifo(pipe_name)
#print "hello"
# pipein = open(pipe_name, 'r')
webpipeque = Queue()
webpipe = Process(target = pipeprocess, args = (webpipeque, pipe_name))
webpipe.start()
conn = sqlite3.connect(sqlite_file, check_same_thread=False)
conn.isolation_level =None
c = conn.cursor()
# Make Queeue
que = Queue()
queue = []
root = Root(c)
'''
lightSensingThread = myThread(root, "light", queue)
temperSensingThread = myThread(root, "temper", queue)
humidSensingThread = myThread(root, "humid", queue)
magnetSensingThread = myThread(root, "magnet", queue)
infraredSensingThread = myThread(root, "infrared", queue)
lightSensingThread.start()
temperSensingThread.start()
humidSensingThread.start()
magnetSensingThread.start()
'''
root.makeDAG()
c.execute('CREATE TABLE {tn} ({nf} {ft})'\
.format(tn = lighttable, nf = "ID", ft="INTEGER"))
# Twisted Application Framework setup:
application = service.Application('twisted-django')
# WSGI container for Django, combine it with twisted.web.Resource:
# XXX this is the only 'ugly' part: see the 'getChild' method in twresource.Root
# The MultiService allows to start Django and Twisted server as a daemon.
multi = service.MultiService()
pool = threadpool.ThreadPool()
tps = ThreadPoolService(pool)
tps.setServiceParent(multi)
import UGM_Database.wsgi
resource = Root.WSGIResource(reactor, tps.pool, UGM_Database.wsgi.application)
root = Root.Root(resource)
mediasrc = static.File(os.path.join(os.path.abspath("."), "static/media"))
staticsrc = static.File(os.path.join(os.path.abspath("."), "static"))
root.putChild("static", staticsrc)
root.putChild("media", mediasrc)
# The cool part! Add in pure Twisted Web Resouce in the mix
# This 'pure twisted' code could be using twisted's XMPP functionality, etc:
import Root as r
from tkinter import *
if __name__ == "__main__":
# "WinProb Files/8L vs 16L vs Blk36Pg24 Fail Raw.prb"
filename = ""
x = r.RootPane(Tk(), filename)
x.show()
def test_calOperation(self):
self.assertEqual(Root.calOperation(self.names, self.miles, self.times),
self.dict1)
def fromxml(input_node):
#debug("XML -> Tree in progress")
#debug("Handling tag " + xml.tag)
node = None
if (input_node.nodeType == 1):
text = None
priority = None
start = None
end = None
comment = None
children = []
# Collecting entry and comment children and node text data
for child in input_node.childNodes:
if (child.nodeType == 1):
if (child.nodeName == "entry"):
children.append(child)
elif (child.nodeName == "comment"):
# Collecting comment string
for i in child.childNodes:
assert (i.nodeType == 3)
if (comment == None):
comment = i.data
else:
comment = comment + i.data
comment = comment.strip()
else:
raise Exceptions.MalformedDatabase("Unknown tag `" +
child.nodeName + "'")
elif (child.nodeType == 3):
if (not child.data.isspace()):
if (text == None):
text = child.data
else:
text = text + child.data
text = text.strip()
elif ((child.nodeType == 2) or (4 <= child.nodeType <= 10)):
# Skip unused nodes
pass
else:
raise Exceptions.UnknownElement(child)
# If we are on root node, build it and skip attributes processing
if (input_node.nodeName == "root"):
if (text == None):
#warning("Database has no name, using default one")
#text = "Default DB name"
raise Exceptions.MalformedDatabase("Missing database name")
node = Root.Root(text)
elif (input_node.nodeName == "entry"):
if (text == None):
raise Exceptions.MalformedDatabase()
# Looking for priority attribute
# debug("Priority is: `" + input_node.getAttribute("start") +
# "'")
priority = Priority.Priority()
if (not input_node.hasAttribute("priority")):
#warning("No priority for entry `" + text + "', using default")
raise Exceptions.MalformedDatabase("No priority for entry " +
"`" + text + "'")
else:
priority.fromstring(str(input_node.getAttribute("priority")))
# Looking for start attribute
value = None
if (input_node.hasAttribute("start")):
value = input_node.getAttribute("start")
try:
start = Time.Time(int(value))
debug("Start time value: `" + str(value) + "'")
# Our exceptions first
except Exceptions, e:
error("Wrong start time format for entry " + "`" + text +
"' (" + str(e) + ")")
raise Exceptions.MalformedDatabase()
except ValueError:
error("Wrong start time for entry " + "`" + text + "'")
raise Exceptions.MalformedDatabase()
except Exception, e:
bug(str(e))
import SCLang
from SCLang import SynthDefs, Env
from SCLang.SynthDefs import *
""" CLOCK """
Clock = TempoClock()
Clock.when_statements = when
when.metro = var.metro = Clock
PlayerObject.metro = Clock
Clock.start()
PlayerObject.server = Server
PlayerObject.default_scale = Scale.default()
PlayerObject.default_root = Root.default()
BufferManager.server = Server
BufferManager.load()
FoxDotCode.namespace = globals()
""" Preset PlayerObjects """
alphabet = 'abcdefghijklmnopqrstuvwxyz'
numbers = '0123456789'
# 1 Letter Player Objects
for char in alphabet:
FoxDotCode.namespace[char] = PlayerObject()
from Root import *
if __name__ == '__main__':
main = Root()
main.mainloop()
This module also handles the time keeping aspect. There is a constant tempo
clock running that has a queue and plays the items accordingly
Note: The code below IS executed in the Environment and can be accessed by the user!
"""
from random import choice as choose
from TempoClock import *
from ServerManager import *
from Players import *
from Patterns import *
from Code import *
from TimeVar import *
from SuperCollider import *
import Scale
import Root
""" SERVER """
Server = ServerManager()
""" CLOCK """
Clock = TempoClock()
Var.metro = Clock
PlayerObject.metro, PlayerObject.server = Clock, Server
Player.default_scale = Scale.default()
Player.default_root = Root.default()
this module, which is analysed and sent back as the raw python code to execute.
This module also handles the time keeping aspect. There is a constant tempo
clock running that has a queue and plays the items accordingly
Note: The code below IS executed in the Environment and can be accessed by the user!
"""
from random import choice as choose
from TempoClock import *
from ServerManager import *
from Players import *
from Patterns import *
from Code import *
from TimeVar import *
from SuperCollider import *
import Scale
import Root
""" SERVER """
Server = ServerManager()
""" CLOCK """
Clock = TempoClock()
Var.metro = Clock
PlayerObject.metro, PlayerObject.server = Clock, Server
Player.default_scale = Scale.default()
Player.default_root = Root.default()
