def load_events_file(self): # The QWidget widget is the base class of all user interface objects in PyQt4. w = QtGui.QWidget() # Set window size. w.resize(320, 240) # Set window title w.setWindowTitle("Hello World!") filename = QtGui.QFileDialog.getOpenFileName( w, 'Open File', '/', "Text Files (*.txt *.csv)") print(filename) try: df = pd.read_csv(str(filename)) if not is_in(REQUIRED_COLS, df.columns): # display error message show_message("Dataframe must contain columns:\n\n{0}".format( ", ".join(REQUIRED_COLS))) else: folder = os_path.dirname(str(filename)) self.events_df = df self.events_df[ "next_img_name"] = folder + self.events_df["next_img_name"] self.images_names = df.next_img_name.unique() self.count = -1 self.update_image(foward=True) except Exception as e: print(e) show_message("Not a valid dataframe")
def get_table(self, ikey, table, current_dict, factor): if not table.isEnabled(): return ncols = table.columnCount() nrows = table.rowCount() current_dict[ikey] = [] for irow in range(0, nrows): dict_row = [] for icol in range(0, ncols): if not table.item(irow, icol): current_dict[ikey] = [] show_message( 'Please provide all the fields for the %s table' % ikey) # dejo que salte el error en el try de accept text = table.item(irow, icol).text() text_parsed = convert_string(text) text_parsed = text_parsed * factor[icol] if ncols == 1: current_dict[ikey].append(text_parsed) else: dict_row.append(text_parsed) if dict_row != []: current_dict[ikey].append(dict_row) return
def plot_table(self): """ plot the current angle-lift or lift-dc table """ key = '' if self.sender().objectName() == "plot_lift_cd_pushButton": key = 'Cd' elif self.sender().objectName() == "plot_angle_lift_pushButton": key = 'Lv' assert (key != '') if key not in self.current_dict.keys() or self.current_dict[key] == []: show_message("Not valid data") return pg.setConfigOptions(background=None) pg.setConfigOptions(foreground='k') xdata = [item[0] for item in self.current_dict[key]] ydata = [item[1] for item in self.current_dict[key]] plot = pg.PlotWidget() set_plot(plot, "Angle [deg]" if key=='Lv' else "Lift[mm]", "Lift [mm]" \ if key=='Lv' else "Discharge Coefficient", "") dialog = QtWidgets.QDialog() dialog.setLayout(QtWidgets.QHBoxLayout()) dialog.layout().addWidget(plot) dialog.setWindowTitle("Angle vs. Lift Plot" if key=='Lv' else \ "Lift vs. Discharge Coefficient") plot.plot(xdata, ydata, pen={'color': 'r', 'width': 1}) dialog.exec_() return
def format_curve(self): curve_format_dialog = CurveFormatDialog() return_value = curve_format_dialog.exec_() if return_value: try: curve_item = self.current_selected_curve color = CURVE_COLORS[ curve_format_dialog.ui_cfd.color.currentText()] line_format = CURVE_LINE_FORMATS[ curve_format_dialog.ui_cfd.line_format.currentText()] width = curve_format_dialog.ui_cfd.width.value() pen = {'color': color, 'width': width, 'style': line_format} curve_item.setPen(pen) legend_text = self.curve_attributes[curve_item][0] plot_type = self.curve_attributes[curve_item][1] figure_number = self.curve_attributes[curve_item][2] # When the curve style is modified, we need to have a reference to # the label that matches with the curve. This information is stored # in the dictionary curve_attributes. Pyqtgraph dont provide # methods to change the item, so I must erease and insert it again. self.legends[plot_type][figure_number].removeItem(legend_text) self.legends[plot_type][figure_number].addItem( curve_item, legend_text) except: show_message('Error trying to set the format of the curve')
def get_table(self, ikey, table, current_dict, factor=1.0): if not table.isEnabled(): return True ncols = table.columnCount() nrows = table.rowCount() current_dict[ikey] = [] if ikey!='state_ini' else current_dict[ikey] for irow in range(0, nrows): dict_row = [] for icol in range(0, ncols): if not table.item(irow,icol): current_dict[ikey] = [] show_message('Please provide all the fields for the %s table'%ikey) return False if not check_if_float(table.item(irow,icol).text(), ikey): show_message('Please provide valid values for the %s table'%ikey) current_dict[ikey] = [] return False text = table.item(irow,icol).text() text_parsed = convert_string(text) text_parsed = text_parsed*factor if ncols==1: current_dict[ikey].append(text_parsed) else: dict_row.append(text_parsed) if dict_row!=[]: current_dict[ikey].append(dict_row) return True
def log_training(self,epoch, iteration, iter, iter_size, stats, dur_iter, epoch_iter, verbose=True): stats = {f'training/{key}': value for key, value in stats.items()} loss_value = [value for value in stats.values()] self._log_losses(iteration, loss_stats=stats) show_message("epoch {:4d} | iter {:>12d} {:>3d}/{:3d} | {:3.2f}s/iter {:d}s/epoch | losses {:>12.6f} {:>12.6f} ".format( epoch, iteration, iter, iter_size, dur_iter, epoch_iter, loss_value[0], loss_value[1] ), verbose=verbose )
def start_game(self): if (len(self.users) == 0): show_message("No User Registed", "", 2) return self.game_started = True for user_index, user in enumerate(self.users): self.step_index += 1 step = Step() step.user = user_index step.index = self.step_index step.action = "setup user" step.command = [ user.username, user.avatar, self.nodes_list[user_index] ] self.broad_cast(step) step = Step() step.action = "start game" self.process(step) self.get_initial_funding() step = Step() step.action = "next turn" self.process(step)
def log_test(self, epoch, stats, verbose=True): if self.rank != 0: return stats = {f'test/{key}': value for key, value in stats.items()} self._log_losses(epoch, loss_stats=stats) show_message( f'Epoch: {epoch} | Losses: {[value for value in stats.values()]}', verbose=verbose)
def log_training(self, iteration, stats, verbose=True): if self.rank != 0: return stats = {f'training/{key}': value for key, value in stats.items()} self._log_losses(iteration, loss_stats=stats) show_message( f'Iteration: {iteration} | Losses: {[value for value in stats.values()]}', verbose=verbose)
def set_linear_table(self): """ set a values defined with linear function (min/max user input) in all the rows of the table """ if self.sender() == self.ui_td.linear_diameter_pushButton: table = self.ui_td.diameter_tableWidget dialog_label1 = 'Insert First Diameter [mm]:' dialog_label2 = 'Insert Second Diameter [mm]:' elif self.sender() == self.ui_td.linear_temperature_pushButton: table = self.ui_td.temperature_tableWidget dialog_label1 = 'Insert First Temperature [K]:' dialog_label2 = 'Insert Second Temperature [K]:' else: return vals = [] for i in range(0, 2): textval = self.input_dialog(dialog_label1 if i == 0 else dialog_label2) if textval == -1: return try: vals.append(float(textval)) except: show_message("Wrong input value") return nrows = self.ui_td.nodalcoord_tableWidget.rowCount() vals = np.linspace(vals[0], vals[1], nrows) table.clearContents() for irow in range(0, nrows): it = QtWidgets.QTableWidgetItem(str(vals[irow])) it.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable) table.setItem(irow, 0, it) return
def __init__(self, stdscr): self.__stdscr = stdscr loading = Loading(stdscr) loading.start() try: cred = Credentials() flag, email, password = cred.get_credentials() if not flag: raise Exception("Invalid credentials") imap = IMAP(email, password) folders = imap.get_mailboxes() options = [] for item in folders: options.append({ 'title': item.replace('"', ''), 'Function': EMAIL_LIST, 'args': (item, imap) }) options.append({'title': "Back", 'Function': None, 'args': None}) loading.stop() Menu(self.__stdscr, options, "Folders") except: loading.stop() utils.show_message(self.__stdscr, "Something went wrong! Press 'q' to go back")
def choose_component(self, component): if component == 'Globals': self.clear_comboboxes([0, 1, 2, 3]) self.ui.variable.addItems(GLOBALS) return self.clear_comboboxes([0, 1, 2, 3]) selected_rpms = self.get_list_items(self.ui.rpms) added_elements = [] for irpm in selected_rpms: rpm_folder = os.path.join(self.current_run_dir, "RPM_%s" % irpm) if not os.path.isdir(rpm_folder): show_message("There is no folder for RPM %s" % irpm) return else: archives = [f for f in os.listdir(rpm_folder) if (COMPONENTS_DICT[component] \ in f and '.txt' in f and 'extras' not in f)] archives.sort() # Para que me aparezcan en orden numerico for index, iarchive in enumerate(archives): iarchive = iarchive.replace('.txt', '') new_element = self.current_objects[component][int( iarchive[-1])].object['label'] if new_element not in added_elements: self.ui.element.addItem(new_element) added_elements.append(new_element) self.choose_element(self.ui.element.currentText()) return
def estimate_average_rtf_on_filelist(filelist_path, config, model, verbose=True): device = next(model.parameters()).device config.training_config.test_filelist_path = filelist_path dataset = AudioDataset(config, training=False) mel_fn = MelSpectrogramFixed(sample_rate=config.data_config.sample_rate, n_fft=config.data_config.n_fft, win_length=config.data_config.win_length, hop_length=config.data_config.hop_length, f_min=config.data_config.f_min, f_max=config.data_config.f_max, n_mels=config.data_config.n_mels, window_fn=torch.hann_window).to(device) rtfs = [] for i in (tqdm(range(len(dataset))) if verbose else range(len(dataset))): datapoint = dataset[i].to(device) mel = mel_fn(datapoint)[None] start = datetime.now() sample = model.forward(mel, store_intermediate_states=False) end = datetime.now() generation_time = (end - start).total_seconds() rtf = compute_rtf(sample, generation_time, sample_rate=config.data_config.sample_rate) rtfs.append(rtf) average_rtf = np.mean(rtfs) std_rtf = np.std(rtfs) show_message(f'DEVICE: {device}. average_rtf={average_rtf}, std={std_rtf}', verbose=verbose) rtf_stats = {'rtfs': rtfs, 'average': average_rtf, 'std': std_rtf} return rtf_stats
def save_file(self, message_shown=True): create_folder() f = open("logs/data_third.txt", "w") f.write(str(self.result_value)) if message_shown: show_message("Інформацію збережено до файлу logs/data_third.txt", QMessageBox.Information) f.close()
def save_file(self, message_shown=True): create_folder() f = open("logs/data_fourth.txt", "w") f.write(str(self.logic.get_z())) if message_shown: show_message("Інформацію збережено до файлу logs/data_fourth.txt", QMessageBox.Information) f.close()
def print_variant(): number = 102 # Номер заліковки variant = number % 10 + 1 output = "Ім'я: Бугайчук Сергій Володимирович" + \ "\nГрупа: ІО-01" + \ "\nНомер у групі: 2" output += "\nВаріант: " + str(variant) show_message(output, QMessageBox.Information)
def change_item(self, item): i, j = item.row(), item.column() if item.text() != str(self.logic.graph[i][j]): if not can_convert_str_to_int(item.text()): show_message("Неправильно уведені дані") self.update_table() else: self.logic.graph[i][j] = self.logic.nx_graph[i][j]['weight'] = int(item.text())
def log_training(self, iteration, loss_stats, verbose=True): show_message( f"""Iteration {iteration} | Backbone loss {loss_stats['backbone_model/total_loss']} | Duration model {loss_stats['duration_model/total_loss']}""", verbose=verbose) self.logger.log(iteration, loss_stats={ f'training/{key}': value for key, value in loss_stats.items() })
def success_simulation(self): if not show_errors(SIMULATOR_PATH) and not self.process_killed: show_message('Simulation Finished', 1) msg = "Do you want to generate the default Post Process?" reply = show_message(msg,4,QtWidgets.QMessageBox.Yes|QtWidgets.QMessageBox.No) if reply == QtWidgets.QMessageBox.Yes: self.plot_defaultPostProcess_after_run_f() self.process_killed = False return
def check_json_keys(self): """ check if the loaded json include all the obligatory keys """ for ikey in JSON_ATMOSPHERE_KEYS: if ikey not in self.current_dict.keys(): show_message("Wrong number of keys in json default atmosphere archive") return False return True
def js_changed(self, index): if self.ui.comboBox_2.itemText(index) == "PBS": if not utils.check_PBS(): utils.show_message("No PBS detected !") self.ui.comboBox_2.setCurrentIndex(0) else: self.jss = str(self.ui.comboBox_2.currentText()) else: pass self.JobCenter.setjss(self.jss)
def __set_confirm_email_bar(self): '''Setup confirm email bar''' try: h, w = self.__stdscr.getmaxyx() self.__stdscr.clear() self.__set_email_list(isConfirm=True) while 1: key = self.__stdscr.getch() if key == curses.KEY_UP and self.__curr_confirm_index != 0: self.__curr_confirm_index -= 1 elif key == curses.KEY_DOWN and self.__curr_confirm_index != len( self.__confirm_menu) - 1: self.__curr_confirm_index += 1 # TODO: Do the functionality according to choice of user elif key == curses.KEY_ENTER or key in [10, 13]: if self.__curr_confirm_index == 0: utils.show_status_message(self.__stdscr, "Deleting email....", isLoading=True) try: num = self.__imap.delete_email(self.__num - self.__arr_position) # Set the new mail count self.__num = num main_list_length = len(self.__main_list) # Update the array self.__main_list.pop(self.__arr_position) if main_list_length - 1 == self.__arr_position: self.__curr_position -= 1 self.__arr_position -= 1 # Show mail sent successfully message utils.show_status_message( self.__stdscr, "Mail deleted Successfully", time_to_show=1) except Exception as e: utils.show_status_message(self.__stdscr, str(e), 2) self.__set_email_list() break self.__set_email_list(isConfirm=True) except: utils.show_message(self.__stdscr, "Something went wrong! Press 'q' to go back")
def change_orientation(self,arg1,data): self.get_panel_properties() if self.orientation != backend.load_setting("orientation"): if self.orientation == None: backend.save_setting('orientation', 'bottom') backend.save_setting('size', self.size) else: utils.show_message(_('Menu needs to restart , restart now?')) backend.save_setting('orientation', self.orientation) backend.save_setting('size', self.size) sys.exit()
def load_configuration(self): (success, new_configuration) = load_configuration_aux(self, 'tube') if not success or not self.check_json_keys(new_configuration): return try: self.current_dict = new_configuration self.set_parameters() show_message('Configuration successfully loaded!', 1) except: show_message('Error trying to set the loaded configuration') return
def func(): if which == 0 and self.universal[0].value( ) > self.logic.get_universal(1): self.universal[0].setValue(self.logic.get_universal(0)) show_message("Укажіть правильний діапазон значень!") if which == 1 and self.universal[1].value( ) < self.logic.get_universal(0): self.universal[1].setValue(self.logic.get_universal(1)) show_message("Укажіть правильний діапазон значень!") self.logic.set_universal(which, self.universal[which].value()) self.synchronize()
def accept(self): success = False try: self.current_dict['state_ini'][0] = float( self.ui_ad.density_lineEdit.text() ) self.current_dict['state_ini'][1] = float( self.ui_ad.velocity_lineEdit.text() ) self.current_dict['state_ini'][2] = float( self.ui_ad.pressure_lineEdit.text() ) success = True except: show_message('Please check that all the fields has correct values') if success: self.close() return
def verify_data(self, rpms, cycles): for ilist in (rpms, cycles): if ilist == []: show_message('Please, select at least one RPM and one cycle') return False cbs = ['element', 'node'] for icb in cbs: cb = self.ui.__getattribute__(icb) if cb.count() == 0: show_message('There are no items for %s' % (icb.capitalize())) return False return True
def print_variant(): g = 1 # Номер групи n = 2 # Номер у списку групи m = "IO" output = "Ім'я: Бугайчук Сергій Володимирович\n" + \ "Група: " + str(m) + "-" + ("0" if g < 10 else "") + str(g) + \ "\nНомер у групі: " + str(n) if m == "IO": n += 1 variant = (n + g % 60) % 30 + 1 output += "\nВаріант: " + str(variant) show_message(output, QMessageBox.Information)
def check_json_keys(self, configuration_to_check=None): """ check if the loaded json include all the obligatory keys """ if not configuration_to_check: configuration_to_check = self.current_dict for ikey in JSON_VALVE_KEYS: if ikey not in configuration_to_check.keys(): show_message( "Wrong number of keys in json default valve archive") return False return True
def __set_email_list(self, isConfirm=False): '''To show the list of emails''' try: # Get the height and width of standard screen h, w = self.__stdscr.getmaxyx() self.__stdscr.clear() # setup title title = "Emails in " + self.__directory_name utils.set_title(self.__stdscr, title) # Start of emali list start = 2 i = 0 # Loop over the list until the screen or list is ended while start < h - 5 and i < len(self.__display_list): # Check if the list item is focused is_focused = i == self.__curr_position # Show the email start = self.__set_mail_item(start, self.__display_list[i]['Subject'], self.__display_list[i]['From'], self.__display_list[i]['Date'], h, w, is_focused=is_focused) i += 1 # Setup the confirm email bottom menu if isConfirm is True if isConfirm: rectangle(self.__stdscr, h - 4, 0, h - 1, w - 2) title = " Do you want to delete email? ".upper() self.__stdscr.attron(curses.A_BOLD) self.__stdscr.addstr(h - 4, 1, title) self.__stdscr.attroff(curses.A_BOLD) self.__display_confirm_bottom_bar_menu() else: # Setup the bottom bar as screen was cleared self.__setup_bottom_bar() # Refresh the layout self.__stdscr.refresh() # Return the total number of shown emails return i except: utils.show_message(self.__stdscr, "Something went wrong! Press 'q' to go back")
def save_postpro(self): name = QtWidgets.QFileDialog.getSaveFileName( self, 'Save Post Process As', "./", "Hierarchical Data Format Files (*.hdf)") filename = name[0] filename = filename + '.hdf' if filename.find( '.hdf') == -1 else filename try: with h5py.File(filename, 'w') as outfile: for itypeplot in range(0, NTYPE_PLOTS): for iplot in range(len(self.plots[itypeplot])): # cada curva del plot, en formato (x,y) plot_items = self.plots[itypeplot][iplot].getPlotItem( ).listDataItems() plot_data = None legends = [] for index, idataitem in enumerate(plot_items): data = idataitem.getData() data = [[data[0][i], data[1][i]] for i in range(len(data[0]))] data = np.array(data) plot_data = np.concatenate( (plot_data, data), axis=0) if plot_data is not None else data legends.append(self.legends[itypeplot] [iplot].items[index][1].text) plot_dataset = outfile.create_dataset( PLOT_ARGUMENTS[itypeplot]['title'] + ' ' + str(iplot), data=plot_data) plot_dataset.attrs['title'] = str( self.plots[itypeplot] [iplot].getPlotItem().titleLabel.text) plot_dataset.attrs['xlabel'] = str( self.plots[itypeplot][iplot].getPlotItem().getAxis( 'bottom').labelText) plot_dataset.attrs['xunits'] = str( self.plots[itypeplot][iplot].getPlotItem().getAxis( 'bottom').labelUnits) plot_dataset.attrs['ylabel'] = str( self.plots[itypeplot][iplot].getPlotItem().getAxis( 'left').labelText) plot_dataset.attrs['yunits'] = str( self.plots[itypeplot][iplot].getPlotItem().getAxis( 'left').labelUnits) plot_dataset.attrs['legends'] = legends plot_dataset.attrs['nplots'] = len(plot_items) show_message('Post Process successfully saved!', 1) except: show_message('Error saving the archive %s' % filename) return
def run(self): """Called at interval, must return number (negative if error)""" raid = self.get_raid() for config_array, config_devices in self.get_config(): try: status, mode, devices = raid[config_array][0:3] for config_device in config_devices.split(","): config_device = config_device.strip() if config_device not in devices: devices_str = "" for part in devices: if len(devices_str) > 0: devices_str += ", " devices_str += part error = "[%s (%s) - %s]: device %s is not present, current devices [%s]" % (config_array, mode, status, config_device, devices_str) show_message(self.logger, logging.WARNING, error) continue except KeyError: error = "[%s]: array doesn't exist" % config_array show_message(self.logger, logging.WARNING, error) continue for dev in raid: status, mode, _, total, count, ready = raid[dev] if total is not None and count is not None and total != count: error = "[%s (%s) - %s]: device count %s is less than total %s [%s]" % (dev, mode, status, count, total, ready) show_message(self.logger, logging.WARNING, error) continue if ready is not None and "_" in ready: error = "[%s (%s) - %s]: device ready contains non ready character [%s]" % (dev, mode, status, ready) show_message(self.logger, logging.WARNING, error) continue return 0
def store_settings(self): """Stores orientation in settings""" if self.orientation != backend.load_setting("orientation"): if self.orientation is None: backend.save_setting('orientation', 'bottom') backend.save_setting('size', self.size) else: utils.show_message(_('Menu needs to restart , restart now?')) backend.save_setting('orientation', self.orientation) backend.save_setting('size', self.size) sys.exit() try: backend.save_setting('orientation', self.orientation) backend.save_setting('size', self.size) except:pass
def change_orientation(self,arg1,data): orient = self.applet.get_orient() self.orientation = None if orient == 1: self.orientation = 'top' else: self.orientation = 'bottom' if self.orientation != backend.load_setting("orientation"): if self.orientation is None: backend.save_setting('orientation', 'bottom') backend.save_setting('size', self.size) else: utils.show_message(_('Menu needs to restart , restart now?')) backend.save_setting('orientation', self.orientation) backend.save_setting('size', self.size) sys.exit()
def run(self): """Called at interval, must return number (negative if error)""" data = self.get_gateway() if data is not None: destination, gateway, flags, dev = data for config_ip, config_gateways in self.get_config(): if destination == config_ip: match = False for config_gateway in config_gateways.split(","): config_gateway = config_gateway.strip() if gateway == config_gateway: match = True if not match: text = "Destination %s has gateway %s (%s) not in [%s] in dev %s" % (destination, gateway, flags, config_gateways, dev) show_message(self.logger, logging.WARNING, text) return 0
def store_settings(self): """Stores orientation in settings""" if self.orientation != backend.load_setting("orientation"): if self.orientation is None: backend.save_setting("orientation", "bottom") backend.save_setting("size", self.size) else: import utils utils.show_message(_("Menu needs to restart , restart now?")) backend.save_setting("orientation", self.orientation) backend.save_setting("size", self.size) sys.exit() try: backend.save_setting("orientation", self.orientation) backend.save_setting("size", self.size) except: pass
def bind_with_custom(self): print 'Using own key method - binding' x = commands.getoutput('xmodmap') if x.find('Super_L') == '-1' and Globals.Settings['Bind_Key'] == 'Super_L': os.system("xmodmap -e 'keycode 115 = Super_L'") os.system('xmodmap -e "add mod4 = Super_L"') try: from Xlib.display import Display from Xlib import X from globalkeybinding import GlobalKeyBinding gtk.gdk.threads_init () keybinding = GlobalKeyBinding (Globals.Settings['Bind_Key']) keybinding.connect ('activate', self.bindkey_callback) keybinding.grab () keybinding.start () except: if Globals.FirstUse: utils.show_message('Please install python xlib') else: print 'Please install python xlib'
def run(self): """Called at interval, must return number (negative if error)""" arp = self.get_arp() for config_ip, config_macs in self.get_config(): try: arp_mac, arp_dev = arp[config_ip] arp_mac = arp_mac.upper() except KeyError: continue match = False for config_mac in config_macs.split(","): config_mac = config_mac.strip().upper() if config_mac == arp_mac: match = True if not match and arp_mac != "00:00:00:00:00:00": text = "IP %s with dev %s has mac %s not in [%s]" % (config_ip, arp_dev, arp_mac, config_macs) show_message(self.logger, logging.WARNING, text) return 0
def run(self): """Called at interval, must return number (negative if error)""" for device, config_code in self.get_config(): error = None status, firmware, test, code = self.get_smart(device) device = device.split(" ")[0] if status is None: continue if status != "Enabled": error = "Device %s doesn't have SMART enabled: %s [%s]" % (device, status, code) elif test != "PASSED": error = "Device %s has test result: %s [%s]" % (device, test, code) elif code != int(config_code): error = "Device %s returned code %s instead of %s" % (device, code, config_code) elif firmware and device not in self.update_notified: self.update_notified.append(device) text = "Device %s has firmware update [%s]" % (device, code) show_message(self.logger, logging.INFO, text) if error is not None: show_message(self.logger, logging.WARNING, error) return 0
# By using, editing and/or distributing this software you agree to # the terms and conditions of this license. # Thank you for using free software! # #(c) Whise 2008, 2009 <*****@*****.**> # # GNOME MENU DIALOG # Part of the GnoMenu import sys try: from Xlib import X, display, Xatom import Xlib except: import utils utils.show_message("Dependency missing: python-xlib not installed.") sys.exit () def get_atom(display, atom_name): atom = XInternAtom(disp, atom_name, False) if atom == None: print "This action requires python xlib installed, please install it for the menu to appear" sys.exit () return atom # Get display disp = Xlib.display.Display() # Get atoms for panel and run dialog menu gnome_panel_atom = disp.intern_atom("_GNOME_PANEL_ACTION") run_atom = disp.intern_atom("_GNOME_PANEL_ACTION_MAIN_MENU") #"_GNOME_PANEL_ACTION_RUN_DIALOG"
raise Exception(msg % (module.name, "run", code)) log.debug(msg % (module.name, "run", code)) module.last_time = time() # Remove if no interval if module.interval == 0: code = safe_call(module.unload, log, None, None, False) log.debug(msg % (module.name, "unload", code)) sleep(0.5) finally: # Attempt to unload modules for module in frozenset(modules): code = safe_call(module.unload, log, None, None, False) log.info(msg % (module.name, "unload", code)) if __name__ == "__main__": try: # open(get_base_dir() + sep + LOG_FILENAME, "w").close() # Clear log error_log = get_logger("Init", [stderr]) error_flag = Event() safe_call(main, error_log, error_flag, None, False) if error_flag.is_set() and not flag_verbose_mode(): show_message(error_log, logging.ERROR, "Error at main") except Exception as e: if not flag_verbose_mode(): show_message(None, logging.ERROR, "Error at main: %s" % e) raise e exit()
def handle_event(self, method, params, connection_ref): """Handle RPC calls and notifications from the pool""" log.warn("@@ %s @@" % method) # Yay, we received something from the pool, # let's restart the timeout. self.reset_timeout() if method == "mining.notify": """Proxy just received information about new mining job""" (job_id, prevhash, coinb1, coinb2, merkle_branch, version, nbits, ntime, clean_jobs) = params[:9] # print len(str(params)), len(merkle_branch) if clean_jobs: log.warn("--Clean Jobs!--") rpc_tx = {"method": "clean_job", "params": [], "id": "cj"} for c in ws_svr: print "ws_svr" print c c.sendMessage(json.dumps(rpc_tx)) """ log.debug("Received new job #%s" % job_id) log.debug("prevhash = %s" % prevhash) log.debug("version = %s" % version) log.debug("nbits = %s" % nbits) log.debug("ntime = %s" % ntime) log.debug("clean_jobs = %s" % clean_jobs) log.debug("coinb1 = %s" % coinb1) log.debug("coinb2 = %s" % coinb2) log.debug("merkle_branch = %s" % merkle_branch) """ # Broadcast to Stratum clients stratum_listener.MiningSubscription.on_template( job_id, prevhash, coinb1, coinb2, merkle_branch, version, nbits, ntime, clean_jobs ) # Broadcast to getwork clients job = Job.build_from_broadcast(job_id, prevhash, coinb1, coinb2, merkle_branch, version, nbits, ntime) log.info( "New job %s for prevhash %s, clean_jobs=%s" % (job.job_id, utils.format_hash(job.prevhash), clean_jobs) ) self.job_registry.add_template(job, clean_jobs) elif method == "mining.set_difficulty": difficulty = params[0] log.info("Setting new difficulty: %s" % difficulty) stratum_listener.DifficultySubscription.on_new_difficulty(difficulty) self.job_registry.set_difficulty(difficulty) elif method == "client.reconnect": (hostname, port, wait) = params[:3] new = list(self.job_registry.f.main_host[::]) if hostname: new[0] = hostname if port: new[1] = port log.info("Server asked us to reconnect to %s:%d" % tuple(new)) self.job_registry.f.reconnect(new[0], new[1], wait) elif method == "client.add_peers": """New peers which can be used on connection failure""" return False """ peerlist = params[0] # TODO for peer in peerlist: self.job_registry.f.add_peer(peer) return True """ elif method == "client.get_version": return "stratum-proxy/%s" % _version.VERSION elif method == "client.show_message": # Displays message from the server to the terminal utils.show_message(params[0]) return True elif method == "mining.get_hashrate": return {} # TODO elif method == "mining.get_temperature": return {} # TODO else: """Pool just asked us for something which we don't support...""" log.error("Unhandled method %s with params %s" % (method, params))
def handle_event(self, method, params, connection_ref): '''Handle RPC calls and notifications from the pool''' # Yay, we received something from the pool, # let's restart the timeout. self.reset_timeout() if method == 'mining.notify': '''Proxy just received information about new mining job''' (job_id, prevhash, coinb1, coinb2, merkle_branch, version, nbits, ntime, clean_jobs) = params[:9] #print len(str(params)), len(merkle_branch) ''' log.debug("Received new job #%s" % job_id) log.debug("prevhash = %s" % prevhash) log.debug("version = %s" % version) log.debug("nbits = %s" % nbits) log.debug("ntime = %s" % ntime) log.debug("clean_jobs = %s" % clean_jobs) log.debug("coinb1 = %s" % coinb1) log.debug("coinb2 = %s" % coinb2) log.debug("merkle_branch = %s" % merkle_branch) ''' # Broadcast to Stratum clients stratum_listener.MiningSubscription.on_template( job_id, prevhash, coinb1, coinb2, merkle_branch, version, nbits, ntime, clean_jobs) # Broadcast to getwork clients job = Job.build_from_broadcast(job_id, prevhash, coinb1, coinb2, merkle_branch, version, nbits, ntime) log.info("New job %s for prevhash %s, clean_jobs=%s" % \ (job.job_id, utils.format_hash(job.prevhash), clean_jobs)) self.job_registry.add_template(job, clean_jobs) elif method == 'mining.set_difficulty': difficulty = params[0] log.info("Setting new difficulty: %s" % difficulty) stratum_listener.DifficultySubscription.on_new_difficulty(difficulty) self.job_registry.set_difficulty(difficulty) elif method == 'client.reconnect': (hostname, port, wait) = params[:3] new = list(self.job_registry.f.main_host[::]) if hostname: new[0] = hostname if port: new[1] = port log.info("Server asked us to reconnect to %s:%d" % tuple(new)) self.job_registry.f.reconnect(new[0], new[1], wait) elif method == 'client.add_peers': '''New peers which can be used on connection failure''' return False ''' peerlist = params[0] # TODO for peer in peerlist: self.job_registry.f.add_peer(peer) return True ''' elif method == 'client.get_version': return "stratum-proxy/%s" % _version.VERSION elif method == 'client.show_message': # Displays message from the server to the terminal utils.show_message(params[0]) return True elif method == 'mining.get_hashrate': return {} # TODO elif method == 'mining.get_temperature': return {} # TODO else: '''Pool just asked us for something which we don't support...''' log.error("Unhandled method %s with params %s" % (method, params))