class Healthy:
def __init__(self, scene, meter_size = (30,4)):
self._health = self.get_max_health()
self.health_bar = Meter(V2(self.x, self.y - self._height / 2), meter_size[0], meter_size[1], PICO_RED, self.get_max_health())
self.health_bar.value = self.health
self.health_bar.offset = (0.5,1)
self.health_bar.stay = False
self.health_bar.visible = 0
self.health_bar._recalc_rect()
scene.ui_group.add(self.health_bar)
@property
def health(self):
return self._health
@health.setter
def health(self, val):
old = self._health
self._health = max(min(val, self.get_max_health()), 0)
if old != self._health:
self.health_bar.value = self._health
self.health_bar.max_value = self.get_max_health()
self.health_bar.show()
def get_max_health(self):
return 0
def run(self):
"""Run the report."""
report_start = time.time()
columns = self._definition.get('columns', [])
items = self._definition.get('items', [])
with self.csv_scope() as csv_scope:
# Iterate over items in definition.
for item in items:
m = Meter(self._client,
item['meter_name'],
max_samples=self.max_samples)
# Meter.read() returns a generator that yields readings.
# One reading per resource/meter pair
for reading in m.read(start=self._start, stop=self._stop):
reading.convert(item.get('conversion'))
line_item = {
c.get('name'): self._encode(
self._field_function(c.get('func'), item, reading))
for c in columns
}
csv_scope.writerow(line_item)
elapsed = time.time() - report_start
logger.info('Report is at {}'.format(self.output.location))
logger.debug('Finished report in {} seconds'.format(elapsed))
def __init__(self):
self.label: int = 0 # identifier string, eg. a number
self.name = '' # full name of this v
self.sname = '' # short name
self.meter = Meter() # meter
self.meter0 = Meter() # meter
self.meter1 = Meter() # meter
self.key = Key() # keysig
self.key0 = Key() # keysig
self.key1 = Key() # keysig
self.stems = 0 # +1 or -1 to force stem direction
self.staves = 0
self.brace = 0
self.bracket = 0
self.do_gch = 0 # 1 to output gchords for this v
self.sep = 0.0 # for space to next v below
self.syms = list() # number of music
self.nsym = len(self.syms)
self.draw = False # flag if want to draw this v
self.select = True # flag if selected for output
self.insert_btype = B_INVIS
self.insert_num = 0 # to split bars over linebreaks
self.insert_bnum = 0 # same for bar number
self.insert_space = 0.0 # space to insert after init syms
self.end_slur = 0 # for a-b slurs
self.insert_text = '' # string over inserted barline
self.timeinit = 0.0 # carryover time between parts
class Test(Frame):
_meter = None
_position = 0
_length = 10000
_step = 500
def __init__(self):
Frame.__init__(self)
# width = (CART_WIDTH + CART_MARGIN) * NUM_COLS
width = METER_WIDTH
self._meter = Meter(self.master, width, self._get_meter_data)
self._meter.grid(row=0, column=0, columnspan=NUM_COLS) #, sticky=E+W
Canvas(self.master, width=900, height=100, bg='#00F').grid(row=2, column=0, columnspan=NUM_COLS)
self._meter.start()
thread.start_new_thread(self._run, ())
self.master.title("Testing Program")
self.master.mainloop()
def _run(self):
while True:
self._position = (self._position + self._step) % self._length
time.sleep(self._step / 1000.)
def _get_meter_data(self):
return (self._position, self._length, "Fruity", "Blergs")
def iterate(self, epoch, phase):
meter = Meter(phase, epoch)
start = time.strftime("%H:%M:%S")
print(f"Starting epoch: {epoch} | phase: {phase} | ⏰: {start}")
batch_size = self.batch_size[phase]
dataloader = self.dataloaders[phase]
running_loss = 0.0
total_batches = len(dataloader)
tk0 = tqdm(dataloader, total=total_batches)
self.optimizer.zero_grad()
for itr, batch in enumerate(tk0):
if phase == "train" and self.do_cutmix:
images, targets = self.cutmix(batch, 0.5)
else:
images, targets = batch
seg_loss, outputs, preds = self.forward(images, targets)
loss = seg_loss / self.accumulation_steps
if phase == "train":
loss.backward()
torch.nn.utils.clip_grad_norm_(self.net.parameters(), 1)
if (itr + 1) % self.accumulation_steps == 0:
self.optimizer.step()
self.optimizer.zero_grad()
running_loss += loss.item()
meter.update(outputs, preds)
tk0.set_postfix(loss=(running_loss / ((itr + 1))))
epoch_loss = (running_loss * self.accumulation_steps) / total_batches
dice, iou, f2 = epoch_log(phase, epoch, epoch_loss, meter, start)
self.losses[phase].append(epoch_loss)
self.dice_scores[phase].append(dice)
self.iou_scores[phase].append(iou)
self.f2_scores[phase].append(f2)
torch.cuda.empty_cache()
return epoch_loss, dice, iou
def validation(self, test_loader):
self.model.eval()
self.model.train(False)
checkpoint = torch.load(self.weight_path, map_location=torch.device('cpu'))
self.model.load_state_dict(checkpoint['state_dict'])
meter = Meter()
tbar = tqdm.tqdm(test_loader, ncols=80)
loss_sum = 0
with torch.no_grad():
for i, (x, labels) in enumerate(tbar):
labels_predict = self.solver.forward(x)
labels_predict = torch.sigmoid(labels_predict)
loss = self.solver.cal_loss(labels, labels_predict, self.criterion)
loss_sum += loss.item()
meter.update(labels, labels_predict.cpu())
descript = "Val Loss: {:.7f}".format(loss.item())
tbar.set_description(desc=descript)
loss_mean = loss_sum / len(tbar)
class_neg_accuracy, class_pos_accuracy, class_accuracy, neg_accuracy, pos_accuracy, accuracy = meter.get_metrics()
print(
"Class_0_accuracy: %0.4f | Class_1_accuracy: %0.4f | Negative accuracy: %0.4f | positive accuracy: %0.4f | accuracy: %0.4f" %
(class_accuracy[0], class_accuracy[1], neg_accuracy, pos_accuracy, accuracy))
return class_neg_accuracy, class_pos_accuracy, class_accuracy, neg_accuracy, pos_accuracy, accuracy, loss_mean
class Test(Frame):
_meter = None
_position = 0
_length = 10000
_step = 500
def __init__(self):
Frame.__init__(self)
# width = (CART_WIDTH + CART_MARGIN) * NUM_COLS
width = METER_WIDTH
self._meter = Meter(self.master, width, self._get_meter_data)
self._meter.grid(row=0, column=0, columnspan=NUM_COLS) #, sticky=E+W
Canvas(self.master, width=900, height=100,
bg='#00F').grid(row=2, column=0, columnspan=NUM_COLS)
self._meter.start()
thread.start_new_thread(self._run, ())
self.master.title("Testing Program")
self.master.mainloop()
def _run(self):
while True:
self._position = (self._position + self._step) % self._length
time.sleep(self._step / 1000.)
def _get_meter_data(self):
return (self._position, self._length, "Fruity", "Blergs")
def __init__(self, parent):
Window.ControlPanel.__init__(self, parent)
self.progressBar = Meter(self,
bg=parent.cget("bg"),
relief=SUNKEN,
bd=2)
self.progressBar.pack(padx=10, pady=5, fill=X, expand=True)
def __init__(self):
"""Construct a Studio window."""
Frame.__init__(self)
# make the window resizable
top = self.master.winfo_toplevel()
for row in range(2, GRID_ROWS + 2):
for col in range(0, GRID_COLS):
top.rowconfigure(row, weight=1)
top.columnconfigure(col, weight=1)
self.rowconfigure(row, weight=1)
self.columnconfigure(col, weight=1)
# initialize the title
title = Label(self.master, font=FONT_TITLE, text=TEXT_TITLE)
title.grid(row=0, column=0, columnspan=GRID_COLS)
# initialize the meter
self._meter = Meter(self.master, METER_WIDTH, self._get_meter_data)
self._meter.grid(row=1, column=0, columnspan=GRID_COLS)
# initialize the cart grid
self._grid = Grid(self, GRID_ROWS, GRID_COLS, True, self._cart_start,
self._cart_stop, self._cart_end, self.add_cart)
# initialize the dual box
self._dual_box = DualBox(self)
self._dual_box.grid(row=GRID_ROWS + 2, column=0, columnspan=4)
# intialize the auto-queue control
self._auto_queue = BooleanVar()
self._auto_queue.set(False)
control = Frame(self.master, bd=2, relief=Tkinter.SUNKEN)
Checkbutton(control,
text=TEXT_AUTOSLOT,
variable=self._auto_queue,
onvalue=True,
offvalue=False).pack(anchor=Tkinter.NW)
control.grid(row=GRID_ROWS + 2, column=4, columnspan=GRID_COLS - 4)
# initialize the search box, button
Label(control, font=FONT, text=TEXT_SEARCHBOX).pack(anchor=Tkinter.NW)
self._entry = Entry(control, takefocus=True, width=45)
self._entry.bind("<Return>", self.search)
# self._entry.grid(row=GRID_ROWS + 3, column=0, columnspan=5)
self._entry.pack(anchor=Tkinter.NW)
self._entry.focus_set()
button = Button(control, text=TEXT_SEARCH, command=self.search)
# button.grid(row=GRID_ROWS + 3, column=5)
button.pack(anchor=Tkinter.S)
# begin the event loop
self.master.protocol("WM_DELETE_WINDOW", self.master.destroy)
self.master.title(TEXT_TITLE)
self.master.mainloop()
def __init__(self, scene, meter_size = (30,4)):
self._health = self.get_max_health()
self.health_bar = Meter(V2(self.x, self.y - self._height / 2), meter_size[0], meter_size[1], PICO_RED, self.get_max_health())
self.health_bar.value = self.health
self.health_bar.offset = (0.5,1)
self.health_bar.stay = False
self.health_bar.visible = 0
self.health_bar._recalc_rect()
scene.ui_group.add(self.health_bar)
def test_generate_power_value(self):
meter_house_a = Meter("HOUSE_A")
loop = asyncio.get_event_loop()
power_value = loop.run_until_complete(meter_house_a.generate_power_value())
self.assertTrue(power_value["house"] is "HOUSE_A")
self.assertIsInstance(power_value["house"], str)
self.assertIsInstance(power_value["datetime"], float)
self.assertIsInstance(power_value["pv"], int)
self.assertTrue(cfg.PV_MIN < power_value["pv"] < cfg.PV_MAX)
def test_publish(self):
try:
meter_house = Meter("HOUSE_TEST")
loop = asyncio.get_event_loop()
loop.run_until_complete(self._publisher.connect_to_broker())
pv_house_a = loop.run_until_complete(
meter_house.generate_power_value())
loop.run_until_complete(self._publisher.publish(pv_house_a))
self.assertTrue(True)
except ConnectionError:
self.assertTrue(False)
def test_put(self):
broker_address = cfg.BROKER_ADDRESS
broker_exchange_name = cfg.EXCHANGE_NAME
broker_queue_name = cfg.QUEUE_NAME
broker_client = BrokerClient(broker_address, broker_exchange_name,
broker_queue_name)
meter_house_a = Meter("HOUSE_A")
loop = asyncio.get_event_loop()
power_value = loop.run_until_complete(
meter_house_a.generate_power_value())
loop.run_until_complete(broker_client.connect())
loop.run_until_complete(broker_client.put(power_value))
self.assertIsInstance(broker_client, BrokerClient)
self.assertTrue(broker_client)
def go(self):
self.meter = Meter(self.duration_seconds, bpm=80)
# Make a random scale
options = range(12)
scale = []
for _ in range(7):
pc = np.random.choice(options)
options.remove(pc)
scale.append(pc)
scale.sort()
print scale
pitch = np.random.randint(62, 76)
for sixteenth in self.meter.layers_by_name['sixteenth']:
if np.random.random() < .8:
# Rest every 10 or so notes
pitch_options = range(max([pitch - 5, 56]),
min([pitch + 6, 88]))
pitch_options.remove(pitch)
pitch_options = [p for p in pitch_options if p % 12 in scale]
pitch = np.random.choice(pitch_options)
note = self.marimba.get_note(pitch)
self.audio.add(sixteenth.start_samples, note)
def __init__(self):
Frame.__init__(self)
# width = (CART_WIDTH + CART_MARGIN) * NUM_COLS
width = METER_WIDTH
self._meter = Meter(self.master, width, self._get_meter_data)
self._meter.grid(row=0, column=0, columnspan=NUM_COLS) #, sticky=E+W
Canvas(self.master, width=900, height=100,
bg='#00F').grid(row=2, column=0, columnspan=NUM_COLS)
self._meter.start()
thread.start_new_thread(self._run, ())
self.master.title("Testing Program")
self.master.mainloop()
def get(self, mid):
TAG = "Gauge:"
module = Module()
meter = Meter()
start_time = time.time()
current_user = get_jwt_identity()
username = current_user['sub']
if (not meter.isUserHasPerm(username, mid)):
return module.unauthorized()
args = request.args
param = "V0, V1, V2, I0, I1, I2, pf0, pf1, pf2, P0, P1, P2, f0, f1, f2, E0, E1, E2"
if (module.isQueryStr(args, "parameters")):
param = args["parameters"]
param = param.replace(" ", ", ")
# print(TAG, "param=", param)
command = """SELECT %s FROM %s ORDER BY DESC LIMIT 1 """ % (param, mid)
# print(TAG, "cmd=", command)
if (not module.isMeterExist(mid)):
return module.measurementNotFound()
res = module.getData(command)
# print(TAG, "res=", res)
results = {"meter_id": "", "parameters": [], "values": []}
gauge_data = {}
if (len(res) > 0):
tmp_res = res[0]
results["meter_id"] = tmp_res["name"]
results["parameters"] = tmp_res["columns"]
results["values"] = tmp_res["values"]
else:
return module.measurementNotFound()
for i in range(len(results["parameters"])):
param_name = results["parameters"][i]
# print(TAG, "param_name=", param_name)
gauge_data[param_name] = results["values"][0][i]
elapsed_time = (time.time() - start_time) * 1000
print(TAG, "times=", elapsed_time, "ms")
return {
"type": True,
"message": "success",
"elapsed_time_ms": elapsed_time,
"result": gauge_data
}
def DownloadMeters(Frequency):
Meters = []
url = "http://delso.pythonanywhere.com/Meter"
resp = UrlResponseVerification(url)
print(resp) ##INSERT
for Row in resp:
Meters = Meters + [[Row[0], Row[1], Row[2], Row[3], Meter(Row[2], Frequency)]]
print('Meters %s\n' % Meters)
return Meters
def __init__(self, scene, meter_size=(30, 4)):
self._health = 1
self.health_bar = Meter(V2(self.x, self.y - self._height / 2),
meter_size[0], meter_size[1], PICO_RED, 1)
self.health_bar.value = self.health
self.health_bar.offset = (0.5, 1)
self.health_bar.stay = False
self.health_bar.visible = 0
self.health_bar._recalc_rect()
scene.ui_group.add(self.health_bar)
self._shield_damage = 0
self.shield_bar = Meter(V2(self.x, self.y - self._height / 2 - 3),
meter_size[0], 2, PICO_BLUE, 1)
self.shield_bar.value = 9999999
self.shield_bar.offset = (0.5, 1)
self.shield_bar.stay = False
self.shield_bar.visible = 0
self.shield_bar._recalc_rect()
scene.ui_group.add(self.shield_bar)
def __init__(self):
"""Construct a Studio window."""
Frame.__init__(self)
# make the window resizable
top = self.master.winfo_toplevel()
for row in range(2, GRID_ROWS + 2):
for col in range(0, GRID_COLS):
top.rowconfigure(row, weight=1)
top.columnconfigure(col, weight=1)
self.rowconfigure(row, weight=1)
self.columnconfigure(col, weight=1)
# initialize the title
title = Label(self.master, font=FONT_TITLE, text=TEXT_TITLE)
title.grid(row=0, column=0, columnspan=GRID_COLS)
# initialize the meter
self._meter = Meter(self.master, METER_WIDTH, self._get_meter_data)
self._meter.grid(row=1, column=0, columnspan=GRID_COLS)
# initialize the cart grid
self._grid = Grid(self, GRID_ROWS, GRID_COLS, True, self._cart_start, self._cart_stop, self._cart_end, self.add_cart)
# initialize the dual box
self._dual_box = DualBox(self)
self._dual_box.grid(row=GRID_ROWS + 2, column=0, columnspan=4)
# intialize the auto-queue control
self._auto_queue = BooleanVar()
self._auto_queue.set(False)
control = Frame(self.master, bd=2, relief=Tkinter.SUNKEN)
Checkbutton(control, text=TEXT_AUTOSLOT, variable=self._auto_queue, onvalue=True, offvalue=False).pack(anchor=Tkinter.NW)
control.grid(row=GRID_ROWS + 2, column=4, columnspan=GRID_COLS - 4)
# initialize the search box, button
Label(control, font=FONT, text=TEXT_SEARCHBOX).pack(anchor=Tkinter.NW)
self._entry = Entry(control, takefocus=True, width=45)
self._entry.bind("<Return>", self.search)
# self._entry.grid(row=GRID_ROWS + 3, column=0, columnspan=5)
self._entry.pack(anchor=Tkinter.NW)
self._entry.focus_set()
button = Button(control, text=TEXT_SEARCH, command=self.search)
# button.grid(row=GRID_ROWS + 3, column=5)
button.pack(anchor=Tkinter.S)
# begin the event loop
self.master.protocol("WM_DELETE_WINDOW", self.master.destroy)
self.master.title(TEXT_TITLE)
self.master.mainloop()
def play(self, player_ui, player_state):
screen = 0
sleep(1)
constants.SOUND_EVENT_DISAPPEAR.play()
utils.draw_sprite(self.scenes[screen])
sleep(1)
player_ui.render()
screen = 0
one = constants.CAREER_EVENT_SEQUENCE_3_BUTTON_1
two = constants.CAREER_EVENT_SEQUENCE_3_BUTTON_2
three = constants.CAREER_EVENT_SEQUENCE_3_BUTTON_3
four = constants.CAREER_EVENT_SEQUENCE_3_BUTTON_4
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.quit()
quit()
if event.key in [pygame.K_DOWN]:
if screen == 3:
constants.SOUND_MENU_SELECTION.play()
one, two, three, four = two, three, four, one
if event.key in [pygame.K_UP]:
if screen == 3:
constants.SOUND_MENU_SELECTION.play()
one, two, three, four = four, one, two, three
if event.key == pygame.K_RETURN:
screen += 1
if screen != 3:
utils.draw_sprite(self.scenes[screen])
player_ui.render()
if screen == 5:
utils.draw_sprite(self.scenes[screen])
constants.SOUND_SAD_EVENT_APPEAR.play()
Meter().play_animation(1)
player_ui.update(2)
player_ui.render()
if screen == 6:
return player_state
if screen == 3:
utils.draw_sprite(one)
player_ui.render()
pygame.display.update()
constants.CLK.tick(constants.FPS)
def run_graphics():
'''This is the PyGame graphics procedure(hardcoding). It will run from
the main function
'''
#initialize screen and colour settings for the screen
pygame.init()
size = [900, 630]
screen = pygame.display.set_mode(size)
black = (0, 0, 0)
white = (255, 255, 255)
clock = pygame.time.Clock()
done = False
#default settings of the magnifying glass
radius = 80
power_meter = Meter(2, 10)
while not done:
# limit speed of while loop to be <10 times per second.
clock.tick(120)
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
if event.type == pygame.KEYDOWN:
#Increase/decrease speed
if event.key == pygame.K_UP:
power_meter.increase()
if event.key == pygame.K_DOWN:
power_meter.decrease()
#set screen background
screen.fill(white)
draw_tree(0, 0, 900, 600, screen, tree_map)
#Detect and store mouse location
pos = pygame.mouse.get_pos()
x = pos[0]
y = pos[1]
if y < 600 or x < 900:
#Checks if the mouse was held down
if pygame.mouse.get_pressed()[0]:
pygame.draw.ellipse(screen, white, [x - 100, y - 100,\
200, 200])
magnify(x, y, radius, power_meter.current, tree_map, screen)
pygame.draw.ellipse(screen, black, [x - 100, y - 100,\
200, 200], 5)
# identify the file mouse is hovering over
hovered_file = file_search(x, y, tree_map)
if hovered_file:
# Select font
font = pygame.font.Font(None, 25)
text = font.render(hovered_file.get_loc(), True, black)
# display location at bottom of screen
screen.blit(text, [10, 605])
# Update the screen
pygame.display.flip()
pygame.quit()
class MeterDaemon(Daemon):
def __init__(self, pid):
self.logger = logging.getLogger(__name__)
self.logger.setLevel(logging.INFO)
##create a file handler
handler = logging.FileHandler('/var/log/meterd.log')
handler.setLevel(logging.INFO)
##create a logging format
formatter = logging.Formatter('%(asctime)s - '
+ '%(name)s - '
+ '%(levelname)s - '
+ '%(message)s')
handler.setFormatter(formatter)
##add the handlers to the logger
self.logger.addHandler(handler)
self.logger.info('Logging started...')
self.logger.info('Pid is:' + pid)
super(MeterDaemon, self).__init__(pid)
self.m = Meter('/dev/ttyUSB0',
57600,
8,
'mastermeter',
'watts',
self.logger)
def run(self):
self.m.open()
self.logger.debug('Meter open.')
while 1:
self.m.read()
self.m.parse()
self.m.submit()
time.sleep(6)
def stop(self):
self.m.close()
self.logger.debug('Meter close.')
super(MeterDaemon, self).stop()
def __init__(self):
"""Construct a CartMachine window."""
Frame.__init__(self)
# make the window resizable
top = self.winfo_toplevel()
for row in range(2, GRID_ROWS + 2):
for col in range(0, GRID_COLS):
top.rowconfigure(row, weight=1)
top.columnconfigure(col, weight=1)
self.rowconfigure(row, weight=1)
self.columnconfigure(col, weight=1)
# initialize the title
title = Label(self.master, font=FONT_TITLE, text=TEXT_TITLE)
title.grid(row=0, column=0, columnspan=GRID_COLS - 1, sticky=Tkinter.N)
# initialize the reload button
reload_button = Button(self.master, \
bg=COLOR_RELOAD_BG, fg=COLOR_RELOAD_FG, \
font=FONT_RELOAD, text=TEXT_RELOAD, \
command=self.reload)
reload_button.grid(row=0, column=GRID_COLS - 1)
# initialize the meter
self._meter = Meter(self.master, METER_WIDTH, self._get_meter_data)
self._meter.grid(row=1, column=0, columnspan=GRID_COLS)
# self._meter.grid_propagate(0)
# initialize the grid
self._grid = Grid(self, GRID_ROWS, GRID_COLS, False, self._cart_start,
self._cart_stop, self._cart_end, None)
self._load()
# begin the event loop
self.master.protocol("WM_DELETE_WINDOW", self.master.destroy)
self.master.title(TEXT_TITLE)
self.mainloop()
def __init__(self):
"""Construct an Automation window."""
Frame.__init__(self)
# initialize title
title = Label(self.master, font=FONT_TITLE, text=TEXT_TITLE)
title.grid(row=0, column=0, columnspan=3)
# initialize button and state
self._state = STATE_STOPPED
self._button_text = StringVar()
self._button = Button(self.master, textvariable=self._button_text, command=self._update_state, width=16, height=2)
self._button.config(bd=2)
self._button.grid(row=0, column=3)
# initialize the meter
self._meter = Meter(self.master, METER_WIDTH, self._get_meter_data)
self._meter.grid(row=1, column=0, columnspan=4)
# initialize playlist view
playlist = Frame(self.master, bd=2, relief=Tkinter.SUNKEN)
Label(playlist, font=FONT, anchor=Tkinter.CENTER, width=16, text=TEXT_PLAYLIST_TIME).grid(row=0, column=0)
Label(playlist, font=FONT, anchor=Tkinter.CENTER, width=32, text=TEXT_PLAYLIST_TRACK).grid(row=0, column=1)
Label(playlist, font=FONT, anchor=Tkinter.CENTER, width=32, text=TEXT_PLAYLIST_ARTIST).grid(row=0, column=2)
inner_playlist = Frame(playlist)
scroll = Scrollbar(inner_playlist, orient=Tkinter.VERTICAL, command=self._scroll_playlist)
self._list_time = Listbox(inner_playlist, selectmode=Tkinter.SINGLE, yscrollcommand=scroll.set, exportselection=0, width=16, height=20)
self._list_track = Listbox(inner_playlist, selectmode=Tkinter.SINGLE, yscrollcommand=scroll.set, exportselection=0, width=32, height=20)
self._list_artist = Listbox(inner_playlist, selectmode=Tkinter.SINGLE, yscrollcommand=scroll.set, exportselection=0, width=32, height=20)
scroll.pack(side=Tkinter.RIGHT, fill=Tkinter.Y)
self._list_time.pack(side=Tkinter.LEFT, fill=Tkinter.X, expand=True, padx=2, pady=2)
self._list_track.pack(side=Tkinter.LEFT, fill=Tkinter.X, expand=True, padx=2, pady=2)
self._list_artist.pack(side=Tkinter.LEFT, fill=Tkinter.X, expand=True, padx=2, pady=2)
inner_playlist.grid(row=1, column=0, columnspan=3)
playlist.grid(row=4, column=0, columnspan=4)
# initialize cart queue
self._cart_queue = CartQueue(self._cart_start, self._cart_stop)
self._cart_queue.add_tracks()
self._update_ui()
# begin the event loop
self.master.protocol("WM_DELETE_WINDOW", self.master.destroy)
self.master.title(TEXT_TITLE)
self.master.mainloop()
def __init__(self, pid):
self.logger = logging.getLogger(__name__)
self.logger.setLevel(logging.INFO)
##create a file handler
handler = logging.FileHandler('/var/log/meterd.log')
handler.setLevel(logging.INFO)
##create a logging format
formatter = logging.Formatter('%(asctime)s - '
+ '%(name)s - '
+ '%(levelname)s - '
+ '%(message)s')
handler.setFormatter(formatter)
##add the handlers to the logger
self.logger.addHandler(handler)
self.logger.info('Logging started...')
self.logger.info('Pid is:' + pid)
super(MeterDaemon, self).__init__(pid)
self.m = Meter('/dev/ttyUSB0',
57600,
8,
'mastermeter',
'watts',
self.logger)
def _dp_parser_v2(logger, acls_conf, dps_conf, meters_conf, routers_conf,
vlans_conf):
dps = []
vid_dp = {}
for identifier, dp_conf in list(dps_conf.items()):
try:
dp = DP(identifier, dp_conf)
dp.sanity_check()
dp_id = dp.dp_id
vlans = {}
for vlan_ident, vlan_conf in list(vlans_conf.items()):
vlans[vlan_ident] = VLAN(vlan_ident, dp_id, vlan_conf)
acls = []
for acl_ident, acl_conf in list(acls_conf.items()):
acls.append((acl_ident, ACL(acl_ident, acl_conf)))
for router_ident, router_conf in list(routers_conf.items()):
router = Router(router_ident, router_conf)
dp.add_router(router_ident, router)
for meter_ident, meter_conf in list(meters_conf.items()):
dp.meters[meter_ident] = Meter(meter_ident, meter_conf)
ports_conf = dp_conf.pop('interfaces', {})
ports = {}
# as users can config port vlan by using vlan name, we store vid in
# Port instance instead of vlan name for data consistency
for port_num, port_conf in list(ports_conf.items()):
port = port_parser(dp_id, port_num, port_conf, vlans)
ports[port_num] = port
if port.native_vlan is not None:
vlan = _get_vlan_by_identifier(dp_id, port.native_vlan,
vlans)
port.native_vlan = vlan
_dp_add_vlan(vid_dp, dp, vlan)
if port.tagged_vlans is not None:
tagged_vlans = []
for vlan_ident in port.tagged_vlans:
vlan = _get_vlan_by_identifier(dp_id, vlan_ident,
vlans)
tagged_vlans.append(vlan)
_dp_add_vlan(vid_dp, dp, vlan)
port.tagged_vlans = tagged_vlans
except AssertionError as err:
logger.exception('Error in config file: %s', err)
return None
for port in list(ports.values()):
dp.add_port(port)
for acl_ident, acl in acls:
dp.add_acl(acl_ident, acl)
dps.append(dp)
return dps
def validation(self, valid_loader):
self.model.eval()
meter = Meter()
tbar = tqdm(valid_loader)
loss_sum = 0
with torch.no_grad():
for i, (images, labels) in enumerate(tbar):
labels_predict = self.solver.forward(images)
# print(labels + (labels_predict.cpu() > 0.5).int())
# labels_predict = labels_predict.unsqueeze(dim=2).unsqueeze(dim=3)
loss = self.solver.cal_loss(labels, labels_predict,
self.criterion)
# loss = F.cross_entropy(labels_predict[0], labels)
loss_sum += loss.item()
meter.update(labels, labels_predict.cpu())
descript = "Val Loss: {:.7f}".format(loss.item())
tbar.set_description(desc=descript)
loss_mean = loss_sum / len(tbar)
class_neg_accuracy, class_pos_accuracy, class_accuracy, neg_accuracy, pos_accuracy, accuracy = meter.get_metrics(
)
print(
"Class_0_accuracy: %0.4f | Positive accuracy: %0.4f | Negative accuracy: %0.4f | \n"
"Class_1_accuracy: %0.4f | Positive accuracy: %0.4f | Negative accuracy: %0.4f |"
%
(class_accuracy[0], class_pos_accuracy[0], class_neg_accuracy[0],
class_accuracy[1], class_pos_accuracy[1], class_neg_accuracy[1]))
# print("Class_0_accuracy: %0.4f | Positive accuracy: %0.4f | Negative accuracy: %0.4f | \n"
# "Class_1_accuracy: %0.4f | Positive accuracy: %0.4f | Negative accuracy: %0.4f | \n"
# "Class_2_accuracy: %0.4f | Positive accuracy: %0.4f | Negative accuracy: %0.4f |" %
# (class_accuracy[0], class_pos_accuracy[0], class_neg_accuracy[0],
# class_accuracy[1], class_pos_accuracy[1], class_neg_accuracy[1],
# class_accuracy[2], class_pos_accuracy[2], class_neg_accuracy[2]))
return class_neg_accuracy, class_pos_accuracy, class_accuracy, neg_accuracy, pos_accuracy, accuracy, loss_mean
def evaluate(model, data_loader, args):
model.eval()
meter = Meter()
with torch.no_grad():
for batch in data_loader:
batch = tuple(t.to(args.device) for t in batch)
_, items = calc_loss(model, batch)
meter.add(*items)
return meter.average(), meter.print_str(False)
def __init__(self):
Frame.__init__(self)
# width = (CART_WIDTH + CART_MARGIN) * NUM_COLS
width = METER_WIDTH
self._meter = Meter(self.master, width, self._get_meter_data)
self._meter.grid(row=0, column=0, columnspan=NUM_COLS) #, sticky=E+W
Canvas(self.master, width=900, height=100, bg='#00F').grid(row=2, column=0, columnspan=NUM_COLS)
self._meter.start()
thread.start_new_thread(self._run, ())
self.master.title("Testing Program")
self.master.mainloop()
def __init__(self, hdf_filename, ID=None):
assert os.path.isfile(hdf_filename)
with pd.get_store(hdf_filename) as store:
metadata = store.root._v_attrs.metadata
if ID is None:
self.ID = hdf_filename.split('/')[-1]
else:
self.ID = ID
self.metadata = metadata
self.filename = hdf_filename
meters_ID = []
for meter_ID in metadata['meters'].keys():
meters_ID.append(meter_ID)
self.meters_ID = meters_ID
meters = []
for meter_ID in metadata['meters'].keys():
meter = Meter.from_user(self, meter_ID)
meters.append(meter)
self.meters = meters
def play(self, player_ui: object, player_state: dict):
screen = 0
sleep(1)
constants.SOUND_EVENT_DISAPPEAR.play()
utils.draw_sprite(self.scenes[screen])
player_ui.update(2) # (player_state)
sleep(1)
player_ui.render()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.quit()
quit()
elif event.key == pygame.K_RETURN:
if screen == 1:
player_state['cash'] -= 1
player_state['heart'] += 1
player_state['face'] -= 2
# utils.draw_sprite(self.scenes[screen])
constants.SOUND_HAPPY_EVENT_APPEAR.play()
Meter().play_animation(2)
player_ui.update(3) # (player_state)
player_ui.render()
if screen == 2:
return player_state
screen += 1
utils.draw_sprite(self.scenes[screen])
# player_ui.update(player_state)
player_ui.render()
pygame.display.update()
constants.CLK.tick(constants.FPS)
def evaluate_kcBert(model, data_loader, args):
model.eval()
meter = Meter()
with torch.no_grad():
for batch in data_loader:
batch = tuple(t.to(args.device) for t in batch)
noise_input_ids, clean_input_ids, noise_mask, clean_mask = batch
outputs = model(noise_input_ids,
labels=clean_input_ids,
attention_mask=noise_mask)
loss = outputs[0]
bsz = clean_input_ids.size(0)
items = [loss.data.item(), bsz, clean_mask.sum().item()]
meter.add(*items)
return meter.average(), meter.print_str(False)
def __init__(self):
"""Construct a CartMachine window."""
Frame.__init__(self)
# make the window resizable
top = self.winfo_toplevel()
for row in range(2, GRID_ROWS + 2):
for col in range(0, GRID_COLS):
top.rowconfigure(row, weight=1)
top.columnconfigure(col, weight=1)
self.rowconfigure(row, weight=1)
self.columnconfigure(col, weight=1)
# initialize the title
title = Label(self.master, font=FONT_TITLE, text=TEXT_TITLE)
title.grid(row=0, column=0, columnspan=GRID_COLS - 1, sticky=Tkinter.N)
# initialize the reload button
reload_button = Button(self.master, \
bg=COLOR_RELOAD_BG, fg=COLOR_RELOAD_FG, \
font=FONT_RELOAD, text=TEXT_RELOAD, \
command=self.reload)
reload_button.grid(row=0, column=GRID_COLS - 1)
# initialize the meter
self._meter = Meter(self.master, METER_WIDTH, self._get_meter_data)
self._meter.grid(row=1, column=0, columnspan=GRID_COLS)
# self._meter.grid_propagate(0)
# initialize the grid
self._grid = Grid(self, GRID_ROWS, GRID_COLS, False, self._cart_start, self._cart_stop, self._cart_end, None)
self._load()
# begin the event loop
self.master.protocol("WM_DELETE_WINDOW", self.master.destroy)
self.master.title(TEXT_TITLE)
self.mainloop()
def create_linear_meter(self, name):
""" Create linear method
:param name: meter name
"""
config = self.meter_config[name]
if config[CHANNELS] == 2:
meter = Meter(self.util, TYPE_LINEAR, config[UI_REFRESH_PERIOD],
self.data_source)
meter.channels = 2
meter.left_x = config[LEFT_X]
meter.left_y = config[LEFT_Y]
meter.right_x = config[RIGHT_X]
meter.right_y = config[RIGHT_Y]
else:
meter = Meter(self.util, TYPE_LINEAR, config[UI_REFRESH_PERIOD],
self.data_source)
meter.x = config[MONO_X]
meter.y = config[MONO_Y]
meter.positions_regular = config[POSITION_REGULAR]
meter.step_width_regular = config[STEP_WIDTH_REGULAR]
if POSITION_OVERLOAD in config:
meter.positions_overload = config[POSITION_OVERLOAD]
meter.step_width_overload = config[STEP_WIDTH_OVERLOAD]
else:
meter.positions_overload = 0
meter.step_width_overload = 0
meter.total_steps = meter.positions_regular + meter.positions_overload + 1
meter.step = 100 / meter.total_steps
meter.add_background(config[BGR_FILENAME])
if config[CHANNELS] == 2:
meter.add_channel(config[INDICATOR_FILENAME], meter.left_x,
meter.left_y)
meter.add_channel(config[INDICATOR_FILENAME], meter.right_x,
meter.right_y)
else:
meter.add_channel(config[INDICATOR_FILENAME], meter.x, meter.y)
meter.add_foreground(config[FGR_FILENAME])
factory = MaskFactory()
meter.masks = factory.create_masks(meter.positions_regular,
meter.positions_overload,
meter.step_width_regular,
meter.step_width_overload)
return meter
def __init__(self, parent):
Window.ControlPanel.__init__(self, parent)
self.progressBar = Meter(self, bg=parent.cget("bg"), relief=SUNKEN, bd=2)
self.progressBar.pack(padx=10, pady=5, fill=X, expand=True)
class Studio(Frame):
"""The Studio class is a GUI for the digital library."""
_meter = None
_grid = None
_dual_box = None
_auto_queue = None
_entry = None
_search_results = None
_selected_cart = None
def __init__(self):
"""Construct a Studio window."""
Frame.__init__(self)
# make the window resizable
top = self.master.winfo_toplevel()
for row in range(2, GRID_ROWS + 2):
for col in range(0, GRID_COLS):
top.rowconfigure(row, weight=1)
top.columnconfigure(col, weight=1)
self.rowconfigure(row, weight=1)
self.columnconfigure(col, weight=1)
# initialize the title
title = Label(self.master, font=FONT_TITLE, text=TEXT_TITLE)
title.grid(row=0, column=0, columnspan=GRID_COLS)
# initialize the meter
self._meter = Meter(self.master, METER_WIDTH, self._get_meter_data)
self._meter.grid(row=1, column=0, columnspan=GRID_COLS)
# initialize the cart grid
self._grid = Grid(self, GRID_ROWS, GRID_COLS, True, self._cart_start, self._cart_stop, self._cart_end, self.add_cart)
# initialize the dual box
self._dual_box = DualBox(self)
self._dual_box.grid(row=GRID_ROWS + 2, column=0, columnspan=4)
# intialize the auto-queue control
self._auto_queue = BooleanVar()
self._auto_queue.set(False)
control = Frame(self.master, bd=2, relief=Tkinter.SUNKEN)
Checkbutton(control, text=TEXT_AUTOSLOT, variable=self._auto_queue, onvalue=True, offvalue=False).pack(anchor=Tkinter.NW)
control.grid(row=GRID_ROWS + 2, column=4, columnspan=GRID_COLS - 4)
# initialize the search box, button
Label(control, font=FONT, text=TEXT_SEARCHBOX).pack(anchor=Tkinter.NW)
self._entry = Entry(control, takefocus=True, width=45)
self._entry.bind("<Return>", self.search)
# self._entry.grid(row=GRID_ROWS + 3, column=0, columnspan=5)
self._entry.pack(anchor=Tkinter.NW)
self._entry.focus_set()
button = Button(control, text=TEXT_SEARCH, command=self.search)
# button.grid(row=GRID_ROWS + 3, column=5)
button.pack(anchor=Tkinter.S)
# begin the event loop
self.master.protocol("WM_DELETE_WINDOW", self.master.destroy)
self.master.title(TEXT_TITLE)
self.master.mainloop()
def _search_internal(self):
"""Search the digital library in a separate thread."""
query = self._entry.get()
if len(query) >= 3:
print "Searching library with query \"%s\"..." % query
self._search_results = database.search_library(query)
self._dual_box.fill(self._search_results)
print "Found %d results." % len(self._search_results)
def search(self, *args):
"""Search the digital library.
:param args
"""
thread.start_new_thread(self._search_internal, ())
def select_cart(self, index):
"""Select a cart from the search results.
:param index: index of cart in search results
"""
if index is not None:
self._selected_cart = self._search_results[index]
def add_cart(self, key):
"""Add the selected cart to the grid.
:param key
"""
if not self._grid.has_cart(key) and self._selected_cart is not None:
self._grid.set_cart(key, self._selected_cart)
def _cart_start(self):
"""Start the meter when a cart starts."""
self._meter.start()
def _cart_stop(self):
"""Reset the meter when a cart stops."""
self._meter.reset()
def _cart_end(self, key):
"""Reset the meter when a cart ends.
Also, if auto-queue is enabled, queue the next cart.
:param key
"""
self._meter.reset()
if self._auto_queue.get():
next_key = get_next_key(GRID_ROWS, GRID_COLS, key)
if self._grid.has_cart(next_key):
self._grid.start(next_key)
def _get_meter_data(self):
"""Get meter data for the currently active cart."""
return self._grid.get_active_cell().get_cart().get_meter_data()
def create_circular_meter(self, name):
""" Create circular method
:param name: meter name
"""
config = self.meter_config[name]
if config[CHANNELS] == 2:
meter = Meter(self.util, TYPE_CIRCULAR, config[UI_REFRESH_PERIOD],
self.data_source)
meter.channels = 2
else:
meter = Meter(self.util, TYPE_CIRCULAR, config[UI_REFRESH_PERIOD],
self.data_source)
meter.steps_per_degree = config[STEPS_PER_DEGREE]
start_angle = config[START_ANGLE]
stop_angle = config[STOP_ANGLE]
meter.incr = (abs(start_angle) + abs(stop_angle)) / 100
meter.add_background(config[BGR_FILENAME])
needle = meter.load_image(config[INDICATOR_FILENAME])[1]
factory = NeedleFactory(needle, config)
meter.needle_sprites = factory.needle_sprites
if config[CHANNELS] == 2:
meter.left_needle_rects = factory.left_needle_rects
meter.right_needle_rects = factory.right_needle_rects
meter.left_needle_rects = factory.left_needle_rects
s = meter.needle_sprites[0]
r = meter.left_needle_rects[0]
meter.add_image(s, 0, 0, r)
r = meter.right_needle_rects[0]
meter.add_image(s, 0, 0, r)
else:
meter.mono_needle_rects = factory.mono_needle_rects
s = meter.needle_sprites[0]
r = meter.mono_needle_rects[0]
meter.add_image(s, 0, 0, r)
if config[FGR_FILENAME]:
meter.add_foreground(config[FGR_FILENAME])
return meter
class CartMachine(Frame):
"""The CartMachine class is a GUI that provides a grid of carts."""
_meter = None
_grid = None
def __init__(self):
"""Construct a CartMachine window."""
Frame.__init__(self)
# make the window resizable
top = self.winfo_toplevel()
for row in range(2, GRID_ROWS + 2):
for col in range(0, GRID_COLS):
top.rowconfigure(row, weight=1)
top.columnconfigure(col, weight=1)
self.rowconfigure(row, weight=1)
self.columnconfigure(col, weight=1)
# initialize the title
title = Label(self.master, font=FONT_TITLE, text=TEXT_TITLE)
title.grid(row=0, column=0, columnspan=GRID_COLS - 1, sticky=Tkinter.N)
# initialize the reload button
reload_button = Button(self.master, \
bg=COLOR_RELOAD_BG, fg=COLOR_RELOAD_FG, \
font=FONT_RELOAD, text=TEXT_RELOAD, \
command=self.reload)
reload_button.grid(row=0, column=GRID_COLS - 1)
# initialize the meter
self._meter = Meter(self.master, METER_WIDTH, self._get_meter_data)
self._meter.grid(row=1, column=0, columnspan=GRID_COLS)
# self._meter.grid_propagate(0)
# initialize the grid
self._grid = Grid(self, GRID_ROWS, GRID_COLS, False, self._cart_start, self._cart_stop, self._cart_end, None)
self._load()
# begin the event loop
self.master.protocol("WM_DELETE_WINDOW", self.master.destroy)
self.master.title(TEXT_TITLE)
self.mainloop()
def _load(self):
"""Load the grid with carts.
Since there are four cart types, each type is assigned
to a corner of the grid, and the carts in that type expand
from that corner. Carts are added one type at a time until
the grid is full.
Typically, since PSAs are the most numerous cart type, they
fill middle space not covered by the other types.
"""
# generate a progression of cells for each corner
progs = {}
for cart_type in CONFIG_CARTS:
progs[cart_type] = progression(GRID_ROWS, GRID_COLS, CONFIG_CARTS[cart_type]["corner"])
# get a dictonary of carts for each cart type
carts = database.get_carts()
# apply shuffling and limiting to each cart type
for cart_type in carts:
random.shuffle(carts[cart_type])
limit = CONFIG_CARTS[cart_type]["limit"]
if limit is not -1:
carts[cart_type] = carts[cart_type][0:limit]
# insert carts until the grid is full or all carts are inserted
num_inserted = 0
for i in range(0, max(GRID_ROWS, GRID_COLS)):
for cart_type in carts:
# insert a layer for each cart type
num_toinsert = 1 + 2 * i
while len(carts[cart_type]) > 0 and num_toinsert > 0:
# pop the first empty coordinate from the progression
key = progs[cart_type].pop(0)
while self._grid.has_cart(key):
key = progs[cart_type].pop(0)
# add the cart to the grid
self._grid.set_cart(key, carts[cart_type].pop(0))
num_inserted += 1
num_toinsert -= 1
# exit if the grid is full
if num_inserted is GRID_ROWS * GRID_COLS:
return
# exit if all carts are inserted
if len([key for key in carts if len(carts[key]) > 0]) is 0:
break
def reload(self):
"""Reload the cart machine."""
if self._grid.is_playing():
return
print "Reloading the Cart Machine..."
self._grid.clear()
self._load()
print "Cart Machine reloaded."
def _cart_start(self):
"""Start the meter when a cart starts."""
self._meter.start()
def _cart_stop(self):
"""Reset the meter when a cart stops."""
self._meter.reset()
def _cart_end(self, key):
"""Reset the meter when a cart ends."""
self._meter.reset()
def _get_meter_data(self):
"""Get meter data for the currently active cart."""
return self._grid.get_active_cell().get_cart().get_meter_data()
def create_linear_meter(self, name):
""" Create linear method
:param name: meter name
"""
config = self.meter_config[name]
if config[CHANNELS] == 2:
meter = Meter(self.util, TYPE_LINEAR, config[UI_REFRESH_PERIOD], self.data_source)
meter.channels = 2
meter.left_x = config[LEFT_X]
meter.left_y = config[LEFT_Y]
meter.right_x = config[RIGHT_X]
meter.right_y = config[RIGHT_Y]
else:
meter = Meter(self.util, TYPE_LINEAR, config[UI_REFRESH_PERIOD], self.data_source)
meter.x = config[MONO_X]
meter.y = config[MONO_Y]
meter.positions_regular = config[POSITION_REGULAR]
meter.step_width_regular = config[STEP_WIDTH_REGULAR]
if POSITION_OVERLOAD in config:
meter.positions_overload = config[POSITION_OVERLOAD]
meter.step_width_overload = config[STEP_WIDTH_OVERLOAD]
else:
meter.positions_overload = 0
meter.step_width_overload = 0
meter.total_steps = meter.positions_regular + meter.positions_overload + 1
meter.step = 100/meter.total_steps
meter.add_background(config[BGR_FILENAME])
if config[CHANNELS] == 2:
meter.add_channel(config[INDICATOR_FILENAME], meter.left_x, meter.left_y)
meter.add_channel(config[INDICATOR_FILENAME], meter.right_x, meter.right_y)
else:
meter.add_channel(config[INDICATOR_FILENAME], meter.x, meter.y)
meter.add_foreground(config[FGR_FILENAME])
factory = MaskFactory()
meter.masks = factory.create_masks(meter.positions_regular, meter.positions_overload, meter.step_width_regular, meter.step_width_overload)
return meter
def create_circular_meter(self, name):
""" Create circular method
:param name: meter name
"""
config = self.meter_config[name]
if config[CHANNELS] == 2:
meter = Meter(self.util, TYPE_CIRCULAR, config[UI_REFRESH_PERIOD], self.data_source)
meter.channels = 2
else:
meter = Meter(self.util, TYPE_CIRCULAR, config[UI_REFRESH_PERIOD], self.data_source)
meter.steps_per_degree = config[STEPS_PER_DEGREE]
start_angle = config[START_ANGLE]
stop_angle = config[STOP_ANGLE]
meter.incr = (abs(start_angle) + abs(stop_angle)) / 100
meter.add_background(config[BGR_FILENAME])
needle = meter.load_image(config[INDICATOR_FILENAME])[1]
factory = NeedleFactory(needle, config)
meter.needle_sprites = factory.needle_sprites
if config[CHANNELS] == 2:
meter.left_needle_rects = factory.left_needle_rects
meter.right_needle_rects = factory.right_needle_rects
meter.left_needle_rects = factory.left_needle_rects
s = meter.needle_sprites[0]
r = meter.left_needle_rects[0]
meter.add_image(s, 0, 0, r)
r = meter.right_needle_rects[0]
meter.add_image(s, 0, 0, r)
else:
meter.mono_needle_rects = factory.mono_needle_rects
s = meter.needle_sprites[0]
r = meter.mono_needle_rects[0]
meter.add_image(s, 0, 0, r)
if config[FGR_FILENAME]:
meter.add_foreground(config[FGR_FILENAME])
return meter
class Automation(Frame):
"""The Automation class is a GUI that provides radio automation."""
_state = None
_button_text = None
_button = None
_meter = None
_cart_queue = None
_list_time = None
_list_track = None
_list_artist = None
def __init__(self):
"""Construct an Automation window."""
Frame.__init__(self)
# initialize title
title = Label(self.master, font=FONT_TITLE, text=TEXT_TITLE)
title.grid(row=0, column=0, columnspan=3)
# initialize button and state
self._state = STATE_STOPPED
self._button_text = StringVar()
self._button = Button(self.master, textvariable=self._button_text, command=self._update_state, width=16, height=2)
self._button.config(bd=2)
self._button.grid(row=0, column=3)
# initialize the meter
self._meter = Meter(self.master, METER_WIDTH, self._get_meter_data)
self._meter.grid(row=1, column=0, columnspan=4)
# initialize playlist view
playlist = Frame(self.master, bd=2, relief=Tkinter.SUNKEN)
Label(playlist, font=FONT, anchor=Tkinter.CENTER, width=16, text=TEXT_PLAYLIST_TIME).grid(row=0, column=0)
Label(playlist, font=FONT, anchor=Tkinter.CENTER, width=32, text=TEXT_PLAYLIST_TRACK).grid(row=0, column=1)
Label(playlist, font=FONT, anchor=Tkinter.CENTER, width=32, text=TEXT_PLAYLIST_ARTIST).grid(row=0, column=2)
inner_playlist = Frame(playlist)
scroll = Scrollbar(inner_playlist, orient=Tkinter.VERTICAL, command=self._scroll_playlist)
self._list_time = Listbox(inner_playlist, selectmode=Tkinter.SINGLE, yscrollcommand=scroll.set, exportselection=0, width=16, height=20)
self._list_track = Listbox(inner_playlist, selectmode=Tkinter.SINGLE, yscrollcommand=scroll.set, exportselection=0, width=32, height=20)
self._list_artist = Listbox(inner_playlist, selectmode=Tkinter.SINGLE, yscrollcommand=scroll.set, exportselection=0, width=32, height=20)
scroll.pack(side=Tkinter.RIGHT, fill=Tkinter.Y)
self._list_time.pack(side=Tkinter.LEFT, fill=Tkinter.X, expand=True, padx=2, pady=2)
self._list_track.pack(side=Tkinter.LEFT, fill=Tkinter.X, expand=True, padx=2, pady=2)
self._list_artist.pack(side=Tkinter.LEFT, fill=Tkinter.X, expand=True, padx=2, pady=2)
inner_playlist.grid(row=1, column=0, columnspan=3)
playlist.grid(row=4, column=0, columnspan=4)
# initialize cart queue
self._cart_queue = CartQueue(self._cart_start, self._cart_stop)
self._cart_queue.add_tracks()
self._update_ui()
# begin the event loop
self.master.protocol("WM_DELETE_WINDOW", self.master.destroy)
self.master.title(TEXT_TITLE)
self.master.mainloop()
def _scroll_playlist(self, *args):
"""Scroll the playlist view.
:param args
"""
self._list_time.yview(*args)
self._list_track.yview(*args)
self._list_artist.yview(*args)
def _update_state(self):
"""Move Automation to the next state.
The state machine is as follows:
STATE_STOPPED -> STATE_PLAYING -> STATE_STOPPING -> STATE_STOPPED
"""
if self._state is STATE_STOPPED:
print "Starting Automation..."
self._cart_queue.start()
self._state = STATE_PLAYING
elif self._state is STATE_PLAYING:
print "Stopping Automation after this track..."
self._cart_queue.stop_soft()
self._state = STATE_STOPPING
elif self._state is STATE_STOPPING:
print "Stopping Automation immediately."
self._cart_queue.transition()
self._state = STATE_STOPPED
self._update_ui()
def _cart_start(self):
"""Start the meter when a cart starts."""
self._meter.start()
self._update_ui()
def _cart_stop(self):
"""Reset the meter when a cart stops.
Also, if a soft stop occured, update the button state.
"""
self._meter.reset()
if self._state is STATE_STOPPING:
self._state = STATE_STOPPED
self._update_ui()
def _update_ui(self):
"""Update the button and playlist."""
self._button_text.set(TEXT_BUTTON[self._state])
self._button.config(bg=COLOR_BUTTON[self._state], highlightbackground=COLOR_BUTTON[self._state])
self._list_time.delete(0, Tkinter.END)
self._list_track.delete(0, Tkinter.END)
self._list_artist.delete(0, Tkinter.END)
for cart in self._cart_queue.get_queue():
self._list_time.insert(Tkinter.END, cart.start_time.strftime("%I:%M:%S %p"))
self._list_track.insert(Tkinter.END, cart.title)
self._list_artist.insert(Tkinter.END, cart.issuer)
def _get_meter_data(self):
"""Get meter data for the first track in the queue."""
queue = self._cart_queue.get_queue()
if len(queue) > 0:
return queue[0].get_meter_data()
else:
return None
def config_monitor(mid, rect):
from meter import Meter;
from widget.linear_meter import LinearMeterWidget;
from widget.circle_meter import CircleMeterWidget;
from widget.surface import SurfaceWidget;
from widget.pango import PangoWidget;
from monitor import Monitor;
from datetime import datetime;
import math;
import cairo;
c = Meter(300, 300);
c.add_widget(LinearMeterWidget(LambdaMonitor(lambda : Monitor.get().cpu_usage),
145, 6, color = (1,1,1), alpha = 0.5,
gravity = LinearMeterWidget.GRAVITY_EAST),
145, 300, 1, 1);
c.add_widget(LinearMeterWidget(LambdaMonitor(lambda : Monitor.get().pmem_usage),
145, 6, color = (1,1,1), alpha = 0.5,
gravity = LinearMeterWidget.GRAVITY_WEST),
155, 300, -1, 1);
c.add_widget(CircleMeterWidget(LambdaMonitor(lambda : (datetime.now().time().hour % 12) / 12.0),
140, 6, -math.pi / 2 + math.pi / 10, -math.pi / 2 - math.pi / 10,
color=(1,1,1), alpha = 0.5, style = CircleMeterWidget.STYLE_SEGMENT),
150, 150, 0, 0);
c.add_widget(CircleMeterWidget(LambdaMonitor(lambda : datetime.now().time().minute / 60.0 + datetime.now().time().second / 3600.0),
128, 10, -math.pi / 2, -math.pi / 2,
color=(1,1,1), alpha = 0.5),
150, 150, 0, 0);
c.add_widget(CircleMeterWidget(LambdaMonitor(lambda : datetime.now().time().second / 60.0),
112, 10, -math.pi / 2 - math.pi / 10, -math.pi / 2 + math.pi / 10,
style=CircleMeterWidget.STYLE_SEGMENT, color=(1,1,1), alpha = 0.5),
150, 150, 0, 0);
c.add_widget(PangoWidget(LambdaMonitor(lambda :
"<span font='Monospace 25'>" + datetime.now().strftime("%H%M%S") + "</span>\n" +
"<span font='Monospace 20'>" + datetime.now().strftime("%y%m%d") + "</span>"),
color=(1,1,1), alpha = 0.5, alignment = "center"),
150, 150, 0, 0);
c.add_widget(PangoWidget(LambdaMonitor(lambda :
"<span font='Monospace 20'>" + str(Monitor.get().gmail_unread_count) + "</span>"),
color=(1,1,1), alpha = 0.5, alignment = "center"),
gmail_icon.get_width(), 0, -1, -1);
c.add_widget(SurfaceWidget(gmail_icon, gmail_icon.get_width(), gmail_icon.get_height()),
0, 0, -1, -1);
c.get_window().move(rect.x + (rect.width - c.width) / 2,
rect.y + (rect.height - c.height) / 2);
c.show();