def test_get_non_existing_cell_raises_exception(self): ss = Spreadsheet(self.basic_data) with self.assertRaises(InvalidCellIdException): ss.get_value(0, -1) with self.assertRaises(InvalidCellIdException): ss.get_value(29, 1)
def test_advance_row(self): spreadsheet = Spreadsheet() spreadsheet.advance_column() spreadsheet.advance_column() spreadsheet.advance_column() self.assertEqual(spreadsheet.current_cell(), 'D1') spreadsheet.advance_row() self.assertEqual(spreadsheet.current_cell(), 'A2')
def test_initialize_and_access_spreadsheet_with_references(self): self.basic_data[0][0] = "10" for j in range(1, Spreadsheet.COLUMNS): self.basic_data[0][j] = "A1" ss = Spreadsheet(self.basic_data) for j in range(Spreadsheet.COLUMNS): self.assertEquals(ss.get_value(0, j), 10)
def test_group_index(): assert Spreadsheet._group_index([]) == [] assert Spreadsheet._group_index([1]) == [[1, 2]] assert Spreadsheet._group_index([1, 2]) == [[1, 3]] assert Spreadsheet._group_index([1, 2, 5]) == [[1, 3], [5, 6]] assert Spreadsheet._group_index([1, 2, 3, 12, 13, 8, 6]) == [[1, 4], [6, 7], [8, 9], [12, 14]]
def check_requests(request_type, auth_file, worksheet_key): """Check for new approved requests""" sheet = Spreadsheet(keyfile=auth_file, sheet_id=worksheet_key) rows = sheet.get_all_rows('Form Responses 1') timestamp = datetime.now().strftime("%d %b %Y %H:%M:%S") processed_rows = [] # set som type-specific things if request_type == 'access': parse_function = parse_user_row csr_type = 'Access Request' elif request_type == 'quota': parse_function = parse_quota_row csr_type = 'Quota Request' else: raise Exception('Unknown request type: `{}`'.format(request_type)) for idx, row in enumerate(rows): if (idx == 0) or (row == []): # skip header row and blank rows continue elif (row[0].lower().strip() == 'approved') and (row[1] == ''): # process rows that are marked approved but not notified request_info = parse_function(row) notify_helpdesk(template=helpdesk_template, sender=helpdesk_email, receiver=helpdesk_email, csr_type=csr_type, priority='High', queue='Monitoring', **request_info) processed_rows.append(idx) if args.log: log_request(args.log, timestamp, request_info['user_email']) elif (row[0] == '') and (datetime.now() >= dateparser.parse(row[2]) + timedelta(hours=24)): # send reminder about rows that have been waiting for approval # for more than 24 hours request_info = parse_function(row) reminder(template=reminder_template, sender=reminder_email, receiver=reminder_email, request_type=request_type, **request_info) else: # skip over unapproved or already-notified rows continue # Google API returns an error if you send an empty request if processed_rows: timestamp_spreadsheet(sheet, timestamp, processed_rows)
def test_get_cells_with_references(self): computed_fib = [0, 1, 1, 2, 3, 5, 8, 13, 21] self.basic_data[0][0] = '0' self.basic_data[0][1] = '1' for j in range(2, Spreadsheet.COLUMNS): self.basic_data[0][j] = "A{} + A{}".format(str(j+1-2), str(j+1-1)) ss = Spreadsheet(self.basic_data) for j in range(Spreadsheet.COLUMNS - 1, -1, -1): self.assertEquals(ss.get_value(0, j), computed_fib[j])
def test_set_value_modifying_references(self): self.basic_data[0][0] = 'A2' self.basic_data[1][0] = 'A1' ss = Spreadsheet(self.basic_data) self.assertEquals(ss.get_value(0, 0), float(self.basic_data[0][1])) self.assertEquals(ss.get_value(1, 0), float(self.basic_data[0][1])) ss.set_value(0, 0, 'A3') self.assertEquals(ss.get_value(0, 0), float(self.basic_data[0][2])) self.assertEquals(ss.get_value(1, 0), float(self.basic_data[0][2]))
def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self.setWindowIcon(QIcon(":/images/icon.png")) self.setCurrentFile("") # ----------- 数据 ------------- self.spreadsheet = Spreadsheet() self.setCentralWidget(self.spreadsheet) self.findDialog = None self.locationLabel = None self.formulaLabel = None self.recentFiles = None # QStringList recentFiles; self.curFile = None # QString curFile; self.MaxRecentFiles = 5 self.recentFileActions = [None] * self.MaxRecentFiles # self.separatorAction = None # # self.fileMenu = None self.editMenu = None self.selectSubMenu = None self.toolsMenu = None self.optionsMenu = None self.helpMenu = None self.fileToolBar = None self.editToolBar = None self.newAction = None self.openAction = None self.saveAction = None self.saveAsAction = None self.exitAction = None self.cutAction = None self.copyAction = None self.pasteAction = None self.deleteAction = None self.selectRowAction = None self.selectColumnAction = None self.selectAllAction = None self.findAction = None self.goToCellAction = None self.recalculateAction = None self.sortAction = None self.showGridAction = None self.autoRecalcAction = None self.aboutAction = None self.aboutQtAction = None # self.qApp = QApplication([]) # 这样写 有问题 self.createActions() self.createMenus() self.createContextMenu() self.createToolBars() self.createStatusBar()
async def on_ready(): # global calls so we can modify these variables global isReady global RolesManager global googleSheet global discordG print(f'{client.user} has connected to Discord') for guild in client.guilds: if guild.name == GUILD: break discordG = guild rosterChan = None for channel in guild.text_channels: if channel.id == chanIds["roster"]: rosterChan = channel googleSheet = Spreadsheet(os.getenv('SHEET_IDENTIFIER')) RolesManager = AshesRolesManager(rosterChan, discordIds, googleSheet) await RolesManager.init(discordIds, guild) isReady = True print("Setup complete")
def __init__(self, test_setup_info, test_data_collection): self.path = Test_Data_Persistence.test_data_path + str(test_setup_info) self.test_data_collection = test_data_collection self.spreadsheet_mode = True self.data_plot_mode = True self.tzero_mode = True self.spreadsheets = {} for key, value in self.test_data_collection.items(): self.spreadsheets[key] = Spreadsheet(self.path, key, value)
def test_letter(self): spreadsheet = Spreadsheet() self.assertEqual(spreadsheet.letter(0), 'A') self.assertEqual(spreadsheet.letter(25), 'Z') self.assertEqual(spreadsheet.letter(26), 'AA') self.assertEqual(spreadsheet.letter(27), 'AB') self.assertEqual(spreadsheet.letter(51), 'AZ') self.assertEqual(spreadsheet.letter(52), 'BA') self.assertEqual(spreadsheet.letter(77), 'BZ') self.assertEqual(spreadsheet.letter(78), 'CA')
def test_set_value_with_references(self): self.basic_data[4][5] = 'A9' ss = Spreadsheet(self.basic_data) new_value = ss.get_value(0, 8) + ss.get_value(1, 5) + 10 ss.set_value(4, 5, 'A9 + B6 + 10') self.assertEquals(ss.get_value(4, 5), new_value)
def test_set_value_with_dependent_cells(self): self.basic_data[0][0] = '0' for j in range(1, Spreadsheet.COLUMNS): self.basic_data[0][j] = 'A%d + 1' % j ss = Spreadsheet(self.basic_data) for j in range(Spreadsheet.COLUMNS): ss.get_value(0, j) ss.set_value(0, 0, '1') for j in range(Spreadsheet.COLUMNS - 1, -1, -1): self.assertEquals(ss.get_value(0, j), j+1)
def show_all(): # TODO make toolbar buttons work ntb = backend_bases.NavigationToolbar2 ntb.toolitems = ( ('Home', 'Reset original view', 'home', 'home'), (None, None, None, None), ('Back', 'Back to previous view', 'back', 'back'), ('Forward', 'Forward to next view', 'forward', 'forward'), (None, None, None, None), ('Save', 'Save the figure', 'filesave', 'save_figure'), ) for column in Spreadsheet().columns(): TTest( title=column.get_title(), measure_unit=column.get_unit(), instrument_error=column.get_instr_err(), nums=column.get_nums(), dpi=130, ).express_solution() plt.show()
def parse_bestworst_data(file, bestCol="best", worstCol="worst", sep=None): """parses best-worst data from file, where each trial is returned as tuple: (best, worst, (unchosen1, unchosen2, ..., unchosen[K-2])) A list of parsed trials is returned. """ # figure out our seperator first if sep == None and file.endswith(".tsv"): sep = "\t" elif sep == None: sep = "," # read in the trials ss = Spreadsheet.read_csv(file, delimiter=sep) trials = [] for row in ss: # read best and worst choices best = row[bestCol] worst = row[worstCol] opts = [] # read all options that were choosable i = 1 while True: col = "option%d" % i if col in ss.header: opts.append(row[col]) i += 1 else: break # strip best and worst choices from the list of other options if best in opts: opts.remove(best) if worst in opts: opts.remove(worst) trials.append((best, worst, tuple(opts))) # return the parsed trials return trials
def main(): session = Session() session.start_session() creds = session.get_credentials() spreadsheet = Spreadsheet(creds) while True: operation = int(input('Operations:\n1 - Read sheet\n2 - Update sheet\n3 - Cancel\n')) if operation == 1: values = spreadsheet.get_spreadsheet_values("A1:E12") spreadsheet.print_sheet(values) elif operation == 2: payment_one = int(input('Payment One: ')) payment_two = int(input('Payment Two: ')) month = int(input('Month: ')) spreadsheet.insert_values_in_sheet(payment_one, payment_two, month) elif operation == 3: break else: print('Invalid operation!')
"Content-Type", "Authorization", "Access-Control-Allow-Credentials" ], supports_credentials=True) api = Api(app) CORS(app, origins="http://127.0.0.1:8080", allow_headers=[ "Content-Type", "Authorization", "Access-Control-Allow-Credentials" ], supports_credentials=True) spreadsheet_args = reqparse.RequestParser() spreadsheet_args.add_argument("text", type=str, required=True) spreadsheet_args.add_argument("url", type=str, required=True) curr_spreadsheet = Spreadsheet() model = MyClassifier(vectorizer='pretrained_glove_50', spreadsheet=curr_spreadsheet, debug=False) class SpreadsheetManager(Resource): def post(self): args = spreadsheet_args.parse_args() url = args["url"] text = args["text"] # get sheet number parsed = urlparse.urlparse(url) gid = parse_qs(parsed.fragment)['gid'][0]
text="Pie Chart", width=button_width, command=lambda: switch_window(pie_chart)).pack() button_frame.grid(column=0, row=0, sticky="NW") # Creates content at the right content_frame = Frame(root) content_frame.grid(column=1, row=0) main_window_list = [] home = Home(content_frame) main_window_list.append(home) num_of_cases = NumOfCases(content_frame) main_window_list.append(num_of_cases) spreadsheet = Spreadsheet(content_frame) main_window_list.append(spreadsheet) time_plot = TimePlot(content_frame) main_window_list.append(time_plot) pie_chart = PieChart(content_frame) main_window_list.append(pie_chart) current_window = home current_window.pack() root.mainloop()
def main(argv=sys.argv[1:]): parser = argparse.ArgumentParser( description= 'Command line for generating best-worst trials from a list of items.') parser.add_argument( "input", type=str, help= "Path to a file containing input data (i.e., a list of words or other text stimuli)." ) parser.add_argument( "N", nargs="?", type=int, default=None, help= "Number of best-worst trials to generate. Suggested amount: number of items, times 8. So if you have 1000 items, 8000 trials. You may get *slightly* better results up to an N of 16, but gains are marginal. You may need fewer trials if your K is larger. Empirical testing not yet done." ) parser.add_argument("K", nargs="?", type=int, default=4, help="Number of items per best-worst trial.") parser.add_argument( "--generator", type=str, default="norepeateven", help= "Method for generating trials. Don't screw with unless you know what you are doing. Options are: random, even, norepeat, norepeateven." ) parser.add_argument( "--column", type=str, default=None, help= "If inputting a structured text file, indicate which column to pull data from." ) parser.add_argument( "--sep", type=str, default=None, help= "Specify the column separator. If None specified, use default (tab for .tsv, comma for all else)" ) args = parser.parse_args() # read in the items to build trials from items = [] if args.input.endswith( ".txt") and args.sep == None and args.column == None: items = [item.strip() for item in open(args.input, "r").read().split()] elif args.column == None: raise Exception( "You must specify a column name with --column= to generate trials this way." ) else: # comma by default or if specified, tab if .tsv sep = args.sep if sep == None and args.input.endswith(".tsv"): sep = "\t" elif sep == None: sep = "," ss = Spreadsheet.read_csv(args.input, delimiter=sep) # take the first column if no column specified items = ss[args.column] # filter out empty strings items = [item for item in items if len(item) > 0] # parse our N and K K = args.K N = args.N if N == None: N = len(items) * 3 # generate trials from items trials = [] if args.generator == "norepeateven": trials = trialgen.build_trials_even_bigram_norepeat(items, N=N, K=K) elif args.generator == 'even': trials = trialgen.build_trials_even(items, N=N, K=K) elif args.generator == 'random': trials = trialgen.build_trials_random(items, N=N, K=K) elif args.generator == "norepeat": trials = trialgen.build_trials_random_bigram_norepeat(items, N=N, K=K) else: raise Exception( "You must specify a proper generation method: norepeateven, even, random, norepeat." ) # print the output, complete with header. # header = [ "option%d" % (i+1) for i in range(K) ] # print(",".join(header)) # for trial in trials: # print(",".join(trial)) # return trials df = pd.DataFrame(trials) df.to_csv("all_trials_reduced.csv")
def test_get_cell_with_auto_reference_raises_exception(self): self.basic_data[0][0] = 'A1' ss = Spreadsheet(self.basic_data) with self.assertRaises(CircularReferenceException): ss.get_value(0, 0)
# Create the Reddit instance reddit = praw.Reddit('bot1') # and login reddit = praw.Reddit(client_id='', client_secret='', user_agent='', username='', password='') subreddit = reddit.subreddit('3dprintmything') # Get the newest 6 values from the subreddit for submission in subreddit.new(limit=6): #print(submission.title) spreadsheet = Spreadsheet(submission.id) seen_bool = spreadsheet.run() counter = 0 # If we haven't seen this post before if not seen_bool: send_sms.send_alert()
class MainWindow(QMainWindow): def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self.setWindowIcon(QIcon(":/images/icon.png")) self.setCurrentFile("") # ----------- 数据 ------------- self.spreadsheet = Spreadsheet() self.setCentralWidget(self.spreadsheet) self.findDialog = None self.locationLabel = None self.formulaLabel = None self.recentFiles = None # QStringList recentFiles; self.curFile = None # QString curFile; self.MaxRecentFiles = 5 self.recentFileActions = [None] * self.MaxRecentFiles # self.separatorAction = None # # self.fileMenu = None self.editMenu = None self.selectSubMenu = None self.toolsMenu = None self.optionsMenu = None self.helpMenu = None self.fileToolBar = None self.editToolBar = None self.newAction = None self.openAction = None self.saveAction = None self.saveAsAction = None self.exitAction = None self.cutAction = None self.copyAction = None self.pasteAction = None self.deleteAction = None self.selectRowAction = None self.selectColumnAction = None self.selectAllAction = None self.findAction = None self.goToCellAction = None self.recalculateAction = None self.sortAction = None self.showGridAction = None self.autoRecalcAction = None self.aboutAction = None self.aboutQtAction = None # self.qApp = QApplication([]) # 这样写 有问题 self.createActions() self.createMenus() self.createContextMenu() self.createToolBars() self.createStatusBar() # self.readSettings() # def closeEvent(self, event): # if (self.okToContinue()): # self.writeSettings() # event.accept() # else: # event.ignore() @pyqtSlot() def newFile(self): if (self.okToContinue()): pass # spreadsheet.clear() # setCurrentFile("") @pyqtSlot() def open(self): pass @pyqtSlot() def save(self): pass @pyqtSlot() def saveAs(self): pass @pyqtSlot() def find(self): pass @pyqtSlot() def goToCell(self): pass @pyqtSlot() def sort(self): pass # 关于 @pyqtSlot() def about(self): QMessageBox.about(self, str("About Spreadsheet"), str("<h2>Spreadsheet 1.1</h2>" "<p>Copyright © 2008 Software Inc." "<p>Spreadsheet is a small application that " "demonstrates QAction, QMainWindow, QMenuBar, " "QStatusBar, QTableWidget, QToolBar, and many other " "Qt classes.")) @pyqtSlot() def openRecentFile(self): pass @pyqtSlot() def updateStatusBar(self): pass def spreadsheetModified(self): pass # 创建 Actions def createActions(self): # 新建 self.newAction = QAction(str("&New"), self) self.newAction.setIcon(QIcon(":/images/new.png")) self.newAction.setShortcut(QKeySequence.New) self.newAction.setStatusTip(str("Create a new spreadsheet file")) self.connect(self.newAction, SIGNAL("triggered()"), self, SLOT("newFile()")) # 打开 self.openAction = QAction(str("&Open..."), self) self.openAction.setIcon(QIcon(":/images/open.png")) self.openAction.setShortcut(QKeySequence.Open) self.openAction.setStatusTip(str("Open an existing spreadsheet file")) self.connect(self.openAction, SIGNAL("triggered()"), self, SLOT("open()")) # 保存 self.saveAction = QAction(str("&Save"), self) self.saveAction.setIcon(QIcon(":/images/save.png")) self.saveAction.setShortcut(QKeySequence.Save) self.saveAction.setStatusTip(str("Save the spreadsheet to disk")) self.connect(self.saveAction, SIGNAL("triggered()"), self, SLOT("save()")) # 另存为 self.saveAsAction = QAction(str("Save &As..."), self) self.saveAsAction.setStatusTip(str("Save the spreadsheet under a name")) self.connect(self.saveAsAction, SIGNAL("triggered()"), self, SLOT("saveAs()")) for i in range(self.MaxRecentFiles): self.recentFileActions[i] = QAction(self) self.recentFileActions[i].setVisible(False) self.connect(self.recentFileActions[i], SIGNAL("triggered()"), self, SLOT("openRecentFile()")) # 退出 self.exitAction = QAction(str("E&xit"), self) self.exitAction.setShortcut(str("Ctrl+Q")) self.exitAction.setStatusTip(str("Exit the application")) self.connect(self.exitAction, SIGNAL("triggered()"), self, SLOT("close()")) # ------------- # 剪切 self.cutAction = QAction(str("Cu&t"), self) self.cutAction.setIcon(QIcon(":/images/cut.png")) self.cutAction.setShortcut(QKeySequence.Cut) self.cutAction.setStatusTip(str("Cut the current selection's contents " "to the clipboard")) self.connect(self.cutAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("cut()")) # 拷贝 self.copyAction = QAction(str("&Copy"), self) self.copyAction.setIcon(QIcon(":/images/copy.png")) self.copyAction.setShortcut(QKeySequence.Copy) self.copyAction.setStatusTip(str("Copy the current selection's contents " "to the clipboard")) self.connect(self.copyAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("copy()")) # 黏贴 self.pasteAction = QAction(str("&Paste"), self) self.pasteAction.setIcon(QIcon(":/images/paste.png")) self.pasteAction.setShortcut(QKeySequence.Paste) self.pasteAction.setStatusTip(str("Paste the clipboard's contents into " "the current selection")) self.connect(self.pasteAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("paste()")) self.deleteAction = QAction(str("&Delete"), self) self.deleteAction.setShortcut(QKeySequence.Delete) self.deleteAction.setStatusTip(str("Delete the current selection's " "contents")) # self.connect(self.deleteAction, SIGNAL("triggered()"), # self.spreadsheet, SLOT(del())) self.selectRowAction = QAction(str("&Row"), self) self.selectRowAction.setStatusTip(str("Select all the cells in the " "current row")) self.connect(self.selectRowAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("selectCurrentRow()")) self.selectColumnAction = QAction(str("&Column"), self) self.selectColumnAction.setStatusTip(str("Select all the cells in the " "current column")) self.connect(self.selectColumnAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("selectCurrentColumn()")) self.selectAllAction = QAction(str("&All"), self) self.selectAllAction.setShortcut(QKeySequence.SelectAll) self.selectAllAction.setStatusTip(str("Select all the cells in the " "spreadsheet")) self.connect(self.selectAllAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("selectAll()")) self.findAction = QAction(str("&Find..."), self) self.findAction.setIcon(QIcon(":/images/find.png")) self.findAction.setShortcut(QKeySequence.Find) self.findAction.setStatusTip(str("Find a matching cell")) self.connect(self.findAction, SIGNAL("triggered()"), self, SLOT("find()")) self.goToCellAction = QAction(str("&Go to Cell..."), self) self.goToCellAction.setIcon(QIcon(":/images/gotocell.png")) self.goToCellAction.setShortcut(str("Ctrl+G")) self.goToCellAction.setStatusTip(str("Go to the specified cell")) self.connect(self.goToCellAction, SIGNAL("triggered()"), self, SLOT("goToCell()")) self.recalculateAction = QAction(str("&Recalculate"), self) self.recalculateAction.setShortcut(str("F9")) self.recalculateAction.setStatusTip(str("Recalculate all the " "spreadsheet's formulas")) self.connect(self.recalculateAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("recalculate()")) self.sortAction = QAction(str("&Sort..."), self) self.sortAction.setStatusTip(str("Sort the selected cells or all the " "cells")) self.connect(self.sortAction, SIGNAL("triggered()"), self, SLOT("sort()")) self.showGridAction = QAction(str("&Show Grid"), self) self.showGridAction.setCheckable(True) self.showGridAction.setChecked(self.spreadsheet.showGrid()) self.showGridAction.setStatusTip(str("Show or hide the spreadsheet's " "grid")) self.connect(self.showGridAction, SIGNAL("toggled(bool)"), self.spreadsheet, SLOT("setShowGrid(bool)")) self.autoRecalcAction = QAction(str("&Auto-Recalculate"), self) self.autoRecalcAction.setCheckable(True) # self.autoRecalcAction.setChecked(self.spreadsheet.autoRecalculate()) self.autoRecalcAction.setStatusTip(str("Switch auto-recalculation on or " "off")) # self.connect(self.autoRecalcAction, SIGNAL("toggled(bool)"),\ # self.spreadsheet, SLOT("setAutoRecalculate(bool)")) self.aboutAction = QAction(str("&About"), self) self.aboutAction.setStatusTip(str("Show the application's About box")) self.connect(self.aboutAction, SIGNAL("triggered()"), self, SLOT("about()")) self.aboutQtAction = QAction(str("About &Qt"), self) self.aboutQtAction.setStatusTip(str("Show the Qt library's About box")) # self.connect(self.aboutQtAction, SIGNAL("triggered()"), self.qApp, SLOT("aboutQt()")) # 创建 菜单栏 def createMenus(self): self.fileMenu = self.menuBar().addMenu(str("&File")) self.fileMenu.addAction(self.newAction) self.fileMenu.addAction(self.openAction) self.fileMenu.addAction(self.saveAction) self.fileMenu.addAction(self.saveAsAction) self.separatorAction = self.fileMenu.addSeparator() for i in range(self.MaxRecentFiles): self.fileMenu.addAction(self.recentFileActions[i]) self.fileMenu.addSeparator() self.fileMenu.addAction(self.exitAction) self.editMenu = self.menuBar().addMenu(str("&Edit")) self.editMenu.addAction(self.cutAction) self.editMenu.addAction(self.copyAction) self.editMenu.addAction(self.pasteAction) self.editMenu.addAction(self.deleteAction) self.selectSubMenu = self.editMenu.addMenu(str("&Select")) self.selectSubMenu.addAction(self.selectRowAction) self.selectSubMenu.addAction(self.selectColumnAction) self.selectSubMenu.addAction(self.selectAllAction) self.editMenu.addSeparator() self.editMenu.addAction(self.findAction) self.editMenu.addAction(self.goToCellAction) self.toolsMenu = self.menuBar().addMenu(str("&Tools")) self.toolsMenu.addAction(self.recalculateAction) self.toolsMenu.addAction(self.sortAction) self.optionsMenu = self.menuBar().addMenu(str("&Options")) self.optionsMenu.addAction(self.showGridAction) self.optionsMenu.addAction(self.autoRecalcAction) self.menuBar().addSeparator() helpMenu = self.menuBar().addMenu(str("&Help")) helpMenu.addAction(self.aboutAction) helpMenu.addAction(self.aboutQtAction) # 添加 上下文菜单,右键快捷菜单 def createContextMenu(self): pass self.spreadsheet.addAction(self.cutAction) self.spreadsheet.addAction(self.copyAction) self.spreadsheet.addAction(self.pasteAction) self.spreadsheet.setContextMenuPolicy(Qt.ActionsContextMenu) def createToolBars(self): pass def createStatusBar(self): pass def readSettings(self): pass def writeSettings(self): pass def okToContinue(self): pass # def loadFile(const QString &fileName) def loadFile(self, fileName): pass # def saveFile(const QString &fileName) def saveFile(self, fileName): pass # def setCurrentFile(const QString &fileName) def setCurrentFile(self, fileName): pass def updateRecentFileActions(self): pass # def strippedName(const QString &fullFileName) def strippedName(self, fullFileName): pass
def handle_websocket(): # assign a uuid to the client client_id = str(uuid.uuid4()) print client_id, 'websocket connected' # request the websocket ws = request.environ.get('wsgi.websocket') if not ws: abort(400, 'Expected WebSocket request.') clients[client_id] = ws state = None while True: try: raw_msg = ws.receive() except: break msg = safely(lambda: json.loads(raw_msg)) if not msg: time.sleep(0.1) continue print 'msg:', msg command = msg.get('command') # {command: "search", keywords: "hello world"} if command == 'search': keywords = msg['keywords'].split() items = pages.search(keywords) ws.send(json.dumps({'command': 'search-results', 'items': items})) # {command: "open", id: "r18r4g18734tr1087t"} elif command == 'open': id = msg['id'] locker( lambda: id in sheets or sheets.update({id: Spreadsheet(id)})) page = pages.retrieve(id) or { 'id': id, 'title': 'new page', 'markup': '', 'code': '' } ws.send(json.dumps({'command': 'page', 'page': page})) # {command: "compute", id: "..." code: "...", formulas: {..}} elif command == 'compute': id = msg['id'] if not id in sheets: continue sheet = sheets[id] if 'code' in msg: context = {} try: exec(msg['code'], {}, context) # NOT SAFE CHECK THIS HERE sheets[id].context = context except: pass changes = msg['formulas'] if changes == None: return for key in changes.keys(): if not changes[key] == '=': safely(lambda: changes.update( {key: ast.literal_eval(changes[key])})) changes = locker(lambda: sheets[id].process(changes)) values = { key: render(value) for key, value in changes['values'].iteritems() } ws.send(json.dumps({'command': 'values', 'values': values})) # {command: "save", page: {id:..., title:..., markup:..., code:...} } elif command == 'save': pages.store(**msg['page'])
encoder = RotaryEncoder.Worker(ENCODER_PIN_A, ENCODER_PIN_B) encoder.start() SWITCH_PIN = 9 switch = Switch(SWITCH_PIN) switch_state = switch.get_state() oled = Oled() contrast = 0 oled.ssd1306.set_contrast(contrast) rgbled.set_sequence(startup_sequence) SPREADSHEET_NAME = 'TimeClock' SPREADSHEET_TEMPLATE = 'TimeClock.ods' ss = Spreadsheet() if not ss.oauth.has_token(): user_code = ss.oauth.get_user_code() print "Go to %s and enter the code %s" % (ss.oauth.verification_url, user_code) # need a font that will show us the full code without scrolling from gaugette.fonts import arial_24 oled.ssd1306.clear_display() oled.ssd1306.draw_text3(0,0,user_code,arial_24) oled.ssd1306.display() ss.oauth.get_new_token() # this call will block until the code is entered if not ss.get_spreadsheet_by_name(SPREADSHEET_NAME): print "Creating new spreadsheet '%s'." % (SPREADSHEET_NAME) ss.create(SPREADSHEET_TEMPLATE, SPREADSHEET_NAME)
def test_initialize_and_access_spreadsheet_without_references(self): ss = Spreadsheet(self.basic_data) for i in range(Spreadsheet.ROWS): for j in range(Spreadsheet.COLUMNS): continue self.assertEquals(ss.get_value(i, j), float(self.basic_data[i][j]))
# -*- coding: utf-8 -*- from telebot import types from telebot import TeleBot from spreadsheet import Spreadsheet import operator import datetime import sys import os sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'resources')) from config import token bot = TeleBot(token) spreadsheet = Spreadsheet() owner_id = '' lean_coffee = {} themes = set() voting = False @bot.message_handler(commands=['lean']) def lean(message): global lean_coffee global themes global owner_id if not owner_id: lean_coffee = {} themes = set()
def setupUi(self, MainWindow): MainWindow.setObjectName("MainWindow") MainWindow.resize(800, 600) self.centralwidget = QtGui.QWidget(MainWindow) self.centralwidget.setObjectName("centralwidget") self.verticalLayout = QtGui.QVBoxLayout(self.centralwidget) self.verticalLayout.setObjectName("verticalLayout") self.horizontalLayout = QtGui.QHBoxLayout() self.horizontalLayout.setObjectName("horizontalLayout") self.timeButton = QtGui.QPushButton(self.centralwidget) self.timeButton.setObjectName("timeButton") self.horizontalLayout.addWidget(self.timeButton) self.downloadButton = QtGui.QPushButton(self.centralwidget) self.downloadButton.setObjectName("downloadButton") self.horizontalLayout.addWidget(self.downloadButton) self.uploadButton = QtGui.QPushButton(self.centralwidget) self.uploadButton.setObjectName("uploadButton") self.horizontalLayout.addWidget(self.uploadButton) self.verticalLayout.addLayout(self.horizontalLayout) self.tableView = Spreadsheet(self.centralwidget) self.tableView.setObjectName("tableView") self.verticalLayout.addWidget(self.tableView) self.horizontalLayout_2 = QtGui.QHBoxLayout() self.horizontalLayout_2.setObjectName("horizontalLayout_2") self.label = QtGui.QLabel(self.centralwidget) self.label.setObjectName("label") self.horizontalLayout_2.addWidget(self.label) self.txTextBrowser = QtGui.QTextBrowser(self.centralwidget) self.txTextBrowser.setMaximumSize(QtCore.QSize(16777215, 100)) self.txTextBrowser.setObjectName("txTextBrowser") self.horizontalLayout_2.addWidget(self.txTextBrowser) self.verticalLayout.addLayout(self.horizontalLayout_2) self.horizontalLayout_3 = QtGui.QHBoxLayout() self.horizontalLayout_3.setObjectName("horizontalLayout_3") self.label_2 = QtGui.QLabel(self.centralwidget) self.label_2.setObjectName("label_2") self.horizontalLayout_3.addWidget(self.label_2) self.rxTextBrowser = QtGui.QTextBrowser(self.centralwidget) self.rxTextBrowser.setMaximumSize(QtCore.QSize(16777215, 100)) self.rxTextBrowser.setObjectName("rxTextBrowser") self.horizontalLayout_3.addWidget(self.rxTextBrowser) self.verticalLayout.addLayout(self.horizontalLayout_3) MainWindow.setCentralWidget(self.centralwidget) self.menubar = QtGui.QMenuBar(MainWindow) self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 19)) self.menubar.setObjectName("menubar") self.menuSoubor = QtGui.QMenu(self.menubar) self.menuSoubor.setObjectName("menuSoubor") self.menuBIOTX = QtGui.QMenu(self.menubar) self.menuBIOTX.setObjectName("menuBIOTX") self.menuNastaveni = QtGui.QMenu(self.menubar) self.menuNastaveni.setObjectName("menuNastaveni") self.menuN_pov_da = QtGui.QMenu(self.menubar) self.menuN_pov_da.setObjectName("menuN_pov_da") MainWindow.setMenuBar(self.menubar) self.statusbar = QtGui.QStatusBar(MainWindow) self.statusbar.setObjectName("statusbar") MainWindow.setStatusBar(self.statusbar) self.actionNov = QtGui.QAction(MainWindow) self.actionNov.setObjectName("actionNov") self.actionOtev_t = QtGui.QAction(MainWindow) self.actionOtev_t.setObjectName("actionOtev_t") self.actionUlo_it = QtGui.QAction(MainWindow) self.actionUlo_it.setObjectName("actionUlo_it") self.actionUlo_it_jako = QtGui.QAction(MainWindow) self.actionUlo_it_jako.setObjectName("actionUlo_it_jako") self.actionDownload_data = QtGui.QAction(MainWindow) self.actionDownload_data.setObjectName("actionDownload_data") self.actionUpload_data = QtGui.QAction(MainWindow) self.actionUpload_data.setObjectName("actionUpload_data") self.actionNastavit_hodiny = QtGui.QAction(MainWindow) self.actionNastavit_hodiny.setObjectName("actionNastavit_hodiny") self.actionZm_na_S_N = QtGui.QAction(MainWindow) self.actionZm_na_S_N.setObjectName("actionZm_na_S_N") self.actionNastaven_korekce = QtGui.QAction(MainWindow) self.actionNastaven_korekce.setObjectName("actionNastaven_korekce") self.actionCOM_Port = QtGui.QAction(MainWindow) self.actionCOM_Port.setObjectName("actionCOM_Port") self.actionHelo = QtGui.QAction(MainWindow) self.actionHelo.setObjectName("actionHelo") self.actionAbout = QtGui.QAction(MainWindow) self.actionAbout.setObjectName("actionAbout") self.menuSoubor.addAction(self.actionNov) self.menuSoubor.addAction(self.actionOtev_t) self.menuSoubor.addAction(self.actionUlo_it) self.menuSoubor.addAction(self.actionUlo_it_jako) self.menuBIOTX.addAction(self.actionDownload_data) self.menuBIOTX.addAction(self.actionUpload_data) self.menuBIOTX.addAction(self.actionNastavit_hodiny) self.menuBIOTX.addAction(self.actionZm_na_S_N) self.menuBIOTX.addAction(self.actionNastaven_korekce) self.menuNastaveni.addAction(self.actionCOM_Port) self.menuN_pov_da.addAction(self.actionHelo) self.menuN_pov_da.addAction(self.actionAbout) self.menubar.addAction(self.menuSoubor.menuAction()) self.menubar.addAction(self.menuBIOTX.menuAction()) self.menubar.addAction(self.menuNastaveni.menuAction()) self.menubar.addAction(self.menuN_pov_da.menuAction()) self.retranslateUi(MainWindow) QtCore.QMetaObject.connectSlotsByName(MainWindow)
def main(argv=sys.argv[1:]): parser = argparse.ArgumentParser( description='Interface for best-worst simulation') parser.add_argument( "input", type=str, help= "A .csv or .tsv input file containing two columns, named by default Item and LatentValue. Item is an identifying label and LatentValue is the item's True value along the dimension to be evaluated." ) parser.add_argument( "N", type=int, help="Number of trials to generate for the simulation.") parser.add_argument("K", type=int, default=4, help="Number of items per trial, defaults to 4.") parser.add_argument( "--noise", type=float, default=0.0, help= "the sd to use for generating noise on each decision (noise is normally distributed)." ) parser.add_argument( "--generator", type=str, default="even", help= "The type of trial generation method for running the simulation. Options are: random, even, norepeat, norepeateven. See Hollis (2017) for details." ) parser.add_argument("--sep", type=str, default=None, help="Column seperator for the input file") parser.add_argument("--item", type=str, default="Item", help="Column corresponding to item name.") parser.add_argument("--latentvalue", type=str, default="LatentValue", help="Column corresponding to latent value name.") parser.add_argument( "--dummy", type=bool, default=True, help="use a dummy player to bound tournament-based scores.") parser.add_argument( "--iters", type=int, default=100, help= "Number of iterations to run tournament-based methods for. 100 is likely sufficient to ensure convergence, if not a little overkill." ) args = parser.parse_args() # determine the column seperator for our input data sep = args.sep if sep == None and args.input.endswith(".tsv"): sep = "\t" elif sep == None: sep = "," # read in latent values from the input data latent_values = {} ss = Spreadsheet.read_csv(args.input, delimiter=sep) for row in ss: latent_values[str(row[args.item])] = row[args.latentvalue] # get the names of our unique items items = latent_values.keys() # parse our N and K K = args.K N = args.N # generate trials from items trials = [] if args.generator == "norepeateven": trials = trialgen.build_trials_even_bigram_norepeat(items, N=N, K=K) elif args.generator == 'even': trials = trialgen.build_trials_even(items, N=N, K=K) elif args.generator == 'random': trials = trialgen.build_trials_random(items, N=N, K=K) elif args.generator == "norepeat": trials = trialgen.build_trials_random_bigram_norepeat(items, N=N, K=K) else: raise Exception( "You must specify a proper generation method: norepeateven, even, random, norepeat." ) # sort words in each trial by their latent value, plus noise trials = [sort_words(trial, latent_values, args.noise) for trial in trials] # convert the trials into format: (best, worst, (others,)) trials = [(trial[0], trial[-1], tuple(trial[1:-1])) for trial in trials] # perform scoring. This takes awhile. methods = [ "Value", "Elo", "RW", "Best", "Worst", "Unchosen", "BestWorst", "ABW", "David", "ValueLogit", "RWLogit", "BestWorstLogit" ] results = scoring.score_trials(trials, methods, iters=args.iters, dummy=args.dummy) # print the header and results header = [args.item, args.latentvalue] + methods print ",".join(header) for name, data in results.iteritems(): # skip dummy items if type(name) != str: continue scores = [scoring.scoring_methods[method](data) for method in methods] out = [name, latent_values[name]] + [str(score) for score in scores] print ",".join([str(v) for v in out])
exit(1) sleep_Period = cfg['DHT']['Period'] site_For_Check = cfg['Main']['Site_for_check'].lower() mail_Status = cfg['email']['Mail_status'] spreadsheet_Status = cfg['Spreadsheet']['Status'] clear_spreadsheet_on_start = cfg['Spreadsheet']['Clear spreadsheet on start'] send_by_str = cfg['Spreadsheet']['Send_by_str'] period_before_send = cfg['Main']['Period_before_send'].split(',') period_before_archive = cfg['Main']['Period_before_arch'].split(',') # Создаем экземляры классов temp_logfile = File(Path, path_To_Temperature_Log, logger) sensor = Sensor(logger, cfg.get('DHT')) mail = Mail(temp_logfile, logger, cfg.get('email')) spr_sheet = Spreadsheet(logger, Path, path_To_Temperature_Log, cfg.get('Spreadsheet')) # Если есть инет, пробуем законнектится if is_Connected(site_For_Check) == True: # Инициализруем почту, если включена отправка почты if mail_Status is True: mail.login() is_Connected_To_Mail = True # Инициализруем гугл докс, если они включены в конфиге if spreadsheet_Status is True: # Логинимся и открываем таблицу spr_sheet.login() spr_sheet.open() # Если нужно, отчищаем гугл таблицу при старте
def test_get_sheet(self): spreadsheet = Spreadsheet() self.assertFalse('Stats' in spreadsheet.workbook.sheetnames) sheet = spreadsheet.get_sheet('Stats') self.assertEqual(sheet.title, 'Stats')
def cli_read(args): api = Spreadsheet(args.creds) cli = CLI(api, args.path) cli.read(args.reset)
def test_select_sheet(self): spreadsheet = Spreadsheet() self.assertNotEqual(spreadsheet.current_sheet().title, 'Stats') spreadsheet.select_sheet('Stats') self.assertEqual(spreadsheet.current_sheet().title, 'Stats')
def cli_write(args): api = Spreadsheet(args.creds) cli = CLI(api, args.path) cli.write(args.spreadsheet_dir, args.editable, args.reset)
def test_cells(self): spreadsheet = Spreadsheet() self.assertEqual(spreadsheet.current_cell(), 'A1') spreadsheet.set_value('1') self.assertEqual(spreadsheet.current_cell(), 'B1') spreadsheet.set_value('1', advance_row=True) self.assertEqual(spreadsheet.current_cell(), 'A2') spreadsheet.set_value('1', advance_by_rows=3) self.assertEqual(spreadsheet.current_cell(), 'A5') spreadsheet.set_values(['1']) self.assertEqual(spreadsheet.current_cell(), 'A6')
def check_requests(request_type, auth_file, worksheet_key): """Check for new approved requests""" # Some definitions that should eventually be set in config TIMESTAMP_FORMAT = "%d %b %Y %H:%M:%S" # hours until first reminder sent reminder_start = timedelta(hours=int(config.get('reminder', 'start'))) # interval to send subsequent reminders reminder_interval = timedelta( hours=int(config.get('reminder', 'interval'))) sheet = Spreadsheet(keyfile=auth_file, sheet_id=worksheet_key) rows = sheet.get_all_rows('Form Responses 1') timestamp = datetime.now().strftime(TIMESTAMP_FORMAT) processed_rows = [] reminder_list = [] reminder_rows = [] now = datetime.now() # set some type-specific things if request_type == 'Access': parse_function = parse_user_row csr_type = 'Access Request' elif request_type == 'Quota': parse_function = parse_quota_row csr_type = 'Change Quota' else: raise Exception('Unknown request type: `{}`'.format(request_type)) for idx, row in enumerate(rows): if (idx == 0) or (row == []): # skip header row and blank rows continue elif (row[0].lower().strip() == 'approved') and (row[1] == ''): # process rows that are marked approved but not notified request_info = parse_function(row) notify_helpdesk(csr_type=csr_type, priority='High', queue='Monitoring', **request_info) processed_rows.append(idx) if args.log: log_request(args.log, timestamp, request_info['user_email']) # if request is not approved and is more than `reminder_start` # hours old, send a reminder elif row[0] == '' and (now >= dateparser.parse(row[3]) + reminder_start): # but only send if this is the first one, or if enough time # has passed since the last one if row[2]: last_sent = datetime.strptime(row[2], TIMESTAMP_FORMAT) else: last_sent = None if not last_sent or (now >= last_sent + reminder_interval): request_info = parse_function(row) reminder_list.append(request_info) reminder_rows.append(idx) else: # skip over unapproved rows <24 hours old, or already-notified rows continue # Skip sending empty requests to Google API because it is slow and returns # an error. Try/catch would handle the error but not avoid the time cost. if processed_rows: timestamp_spreadsheet(sheet, timestamp, processed_rows, column=1) if reminder_list: send_reminder(request_type=request_type, reminders=reminder_list, worksheet_key=worksheet_key) timestamp_spreadsheet(sheet, timestamp, reminder_rows, column=2)
import yaml from spreadsheet import Spreadsheet from garo_gm3d import Garo with open("config.yml", "r") as ymlfile: cfg = yaml.load(ymlfile) print "Listening to energy meter on gpio pin {0}".format(cfg["gpio_pin"]) print 'Loading oauth info from the file "{0}"'.format(cfg["gdocs_oauth_json"]) print 'Logging energy meter to spreadsheet "{0}" every {1} seconds.'.format( cfg["gdocs_spreadsheet_name"], cfg["frequency_seconds"] ) print "Press Ctrl-C to quit." # Initialize the spreadsheet spreadsheet = Spreadsheet(cfg["gdocs_oauth_json"], cfg["gdocs_spreadsheet_name"], cfg["gdocs_spreadsheet_worksheet"]) # Get the current energy meter standing from the spreadsheet on cell B1 current_watt_hours = spreadsheet.get_cell_value("B1") current_watt_hours = int(current_watt_hours) print "Current energy meter standing (as read from the spreadsheet in column B1) is {}Wh".format(current_watt_hours) # Initialize the Garo GM3D garo = Garo(cfg["gpio_pin"], current_watt_hours) garo.listen() while True: current_watt_hours = garo.get_watt_hours() spreadsheet.append_row((datetime.datetime.now(), current_watt_hours)) spreadsheet.update_cell_value("B1", current_watt_hours) time.sleep(cfg["frequency_seconds"])
def cli_summary_read(args): api = Spreadsheet(args.creds) cli = CLI(api, args.path) cli.summary_read(args.spreadsheet_dir, args.reset)
def test_set_value_without_references(self): ss = Spreadsheet(self.basic_data) new_value = ss.get_value(4, 5) + 10 ss.set_value(4, 5, str(new_value)) self.assertEquals(ss.get_value(4, 5), new_value)
def cli_summary_transform(args): api = Spreadsheet(args.creds) cli = CLI(api, args.path) cli.summary_transform(args.fracking)
def import_to_googlesheets(records, search_term, credentials): ss = Spreadsheet(credentials, debug_mode=False) try: f = open('temp.txt', 'x') email = input('Email: ') ss.create('Amazon', search_term) ss.share_with_email_for_writing(email) f.write(ss.spreadsheet_id) f.close() except FileExistsError: f = open('temp.txt', 'r') ss.set_spreadsheet_by_id(f.read()) try: ss.add_sheet(search_term) except googleapiclient.errors.HttpError: ss.set_sheet_by_title(search_term) ss.clear_sheet() f.close() finally: ss.prepare_set_values('A1:E1', [['Name', 'Price', 'Rating', 'Reviews', 'Url']]) ss.prepare_set_values('A2:E%d' % (len(records) + 1), records) ss.run_prepared()
def cli_summary_write(args): api = Spreadsheet(args.creds) cli = CLI(api, args.path) cli.summary_write(args.spreadsheet_dir)
def cli_matches(args): api = Spreadsheet(args.creds) cli = CLI(api, args.path) cli.matches(args.spreadsheet_dir)
def main(argv = sys.argv[1:]): parser = argparse.ArgumentParser(description='Command line for filtering noncompliant participants from best-worst data.') parser.add_argument("scores", type=str, help="Path to a file containing scores computed over all users (including noncompliant ones).") parser.add_argument("input", nargs="*", type=str, help="Path to a file(s) containing trial-level data.") parser.add_argument("--id_column", type=str, default=None, help="A column in your input data that specifies user ID. If no value is supplied, uses the name of the file.") parser.add_argument("--best", type=str, default="best", help="Name of column that holds string of 'best' choice.") parser.add_argument("--worst", type=str, default="worst", help="Name of column that holds string of 'worst' choice.") parser.add_argument("--score_method", type=str, default="Value", help="The scoring method to calculate compliance by.") parser.add_argument("--filter", type=float, default=None, help="If you want to filter users by compliance, specify the threshold here. The output will be the trials for just users who met your threshold of compliance, as a single file. This can be submitted to score_trials.py for rescoring.") args = parser.parse_args() # read the scores ss = Spreadsheet.read_csv(args.scores) scores = { } for row in ss: scores[row[0]] = row[args.score_method] # go through each file and calculate participant compliance and log their # trials compliance = { } paircount = { } user_trials = { } for file in args.input: # if a participant ID column is not specified, use the name of the file. # Otherwise, use values in the specified column to determine ID. id_col = None if args.id_column != None: ss = Spreadsheet.read_csv(file) id_col = ss[args.id_column] # read in the user's data, calculate compliance for each trial trials = scoring.parse_bestworst_data(file, bestCol=args.best, worstCol=args.worst) # generate a user ID based on the file name if id_col == None: id_col = [ file ] * len(trials) # check for agreement on each trial for i in xrange(len(trials)): id = id_col[i] trial = trials[i] best, worst, others = trial # something funny going on in your data; check it out duplic = best == worst # skip trial if best == worst if duplic == True: continue # set default values for participant if needed if id not in compliance: compliance[id] = 0 paircount[id] = 0 user_trials[id]= [ ] # calculate compliance pairs = [ (best, other) for other in ((worst,) + others) ] + [ (other, worst) for other in others ] consistent = [ scores[pair[0]] > scores[pair[1]] for pair in pairs ] compliance[id] += sum(consistent) paircount[id] += len(pairs) user_trials[id].append(trial) # calculate overall accuracy for each participant accuracy = { } for user in compliance.iterkeys(): accuracy[user] = float(compliance[user]) / paircount[user] # print compliance for each person if args.filter == None: # sort users by their accuracy users = accuracy.keys() users.sort(lambda a,b: cmp(accuracy[a], accuracy[b]), reverse=True) print "ID,Compliance" for user in users: print "%s,%0.3f" % (str(user), accuracy[user]) # print trials for users that meet the filter threshold else: user_count = 0 for user in accuracy.iterkeys(): # skip by everyone who doesn't make the cut if accuracy[user] < args.filter: continue # print out data for everyone else best,worst,others = user_trials[user][0] options = list(others) # do we need to print the header? if user_count == 0: optCols = [ "option%d" % (i+1) for i in xrange(len(options)) ] header = [ "User", "best", "worst" ] + optCols print ",".join(header) # print out each trial for the user for trial in user_trials[user]: best,worst, others = trial options = list(others) out = [ user, best, worst ] + options out = [ str(v) for v in out ] print ",".join(out) # increment our users user_count += 1