rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
ta.setFragmentParent(self) | ta.setFragmentParent(enc) | def showConversation(self, conversation, conversationName): """ Bring a conversation to the foreground. |
pass | print "%20s %-50s" % (name, toks) | def reporter(s, loc, toks): pass # print "%20s %-50s" % (name, toks) |
actor.setParseAction(R("actor")) | def reporter(s, loc, toks): pass # print "%20s %-50s" % (name, toks) | |
part_of_speech.setParseAction(R("part_of_speech")) | def _bookendedVerb(opener, terminator): o = L(opener) t = L(terminator) wordchars = P.alphanums + string.punctuation.replace(terminator, '') v_word = P.Word(wordchars) v_words = P.OneOrMore(v_word) v_word_nonterminal = v_word + P.NotAny(t) v_words_nonterminal = P.OneOrMore(v_word_nonterminal) # FIXME - [d20 1d10] sh... | |
def requestAvatarId(self, credentials): | def requestAvatarId(self, creds): | def requestAvatarId(self, credentials): store = theGlobal['database'] |
username = unicode(credentials.username) | username = unicode(creds.username) | def requestAvatarId(self, credentials): store = theGlobal['database'] |
if userbase.IPreauthCredentials.providedBy(credentials): | if userbase.IPreauthCredentials.providedBy(creds): | def requestAvatarId(self, credentials): store = theGlobal['database'] |
elif credentials.IUsernamePassword.providedBy(credentials): password = unicode(credentials.password) | elif credentials.IUsernamePassword.providedBy(creds): password = unicode(creds.password) | def requestAvatarId(self, credentials): store = theGlobal['database'] |
def _setServer(netmodel): """FIXME - set a server so we can test things out""" netmodel.server = '127.0.0.1' | def run(argv = None): if argv is None: argv = sys.argv o = Options() o.parseOptions(argv[1:]) try: logfile = file(o['logfile'], 'w+') log.startLogging(logfile) except (TypeError, EnvironmentError): log.startLogging(sys.stderr) d = defer.Deferred() netmodel = NetModel() netclient = NetClient(netmodel) bigctl = BigCo... | |
GeeEm('VellumTalk', '.gm', ('GeeEm', r'GeeEm is now a GM and will observe private messages for session Player('VellumTalk', '[stabtastic 20]', ('GeeEm', r'Player, you rolled: stabtastic 20 = \[20\] \(<Player> \[stabtastic 20\]\)'), ('Player', r'Player, you rolled: stabtastic 20 = \[20\] \(observed\)') ) | def succeed(): global passed passed = passed + 1 sys.stdout.write('.') | |
if cn in self.textareas: | if cn in self.conversations: | def hideConversation(self, conversation, conversationName): """ Make a conversation disappear. """ cn = unicode(conversationName) if cn in self.textareas: d = self.removeTab(cn) del self.textareas[cn] else: d = defer.succeed(None) # FIXME - we do not return this deferred. Need to see whether # minchat deals with defer... |
del self.textareas[cn] | del self.conversations[cn] | def hideConversation(self, conversation, conversationName): """ Make a conversation disappear. """ cn = unicode(conversationName) if cn in self.textareas: d = self.removeTab(cn) del self.textareas[cn] else: d = defer.succeed(None) # FIXME - we do not return this deferred. Need to see whether # minchat deals with defer... |
return None | return u'ok' | def irccmdFallback(message, conv): strCommand = parsed.commandWord.encode('utf8').upper() message = '%s %s' % (strCommand, message) return self.irccmd_raw(message, conv) |
[pt/last_zoom * zoom for pt in (box_w, box_h, x1,y1,x2,y2)]) | [pt * zoom for pt in (box_w, box_h, x1,y1,x2,y2)]) | def finish(self): """Zoom so the inscribed area is maximized in the main window""" if self.drawn: x1 = self.drawn.get_property('x1') y1 = self.drawn.get_property('y1') x2 = self.drawn.get_property('x2') y2 = self.drawn.get_property('y2') |
self.__regex_from = re.compile('^from: .*$', re.IGNORECASE) self.__regex_to = re.compile('^to: .*$', re.IGNORECASE) self.__regex_subject = re.compile('^subject: .*$', re.IGNORECASE) self.__regex_msgid = re.compile('^message-id: .*$', re.IGNORECASE) self.__regex_date = re.compile('^date: .*$', re.IGNORECASE) self.__rege... | def __init__(self): self.__regex_from = re.compile('^from: .*$', re.IGNORECASE) self.__regex_to = re.compile('^to: .*$', re.IGNORECASE) self.__regex_subject = re.compile('^subject: .*$', re.IGNORECASE) self.__regex_msgid = re.compile('^message-id: .*$', re.IGNORECASE) self.__regex_date = re.compile('^date: .*$', re.IGN... | |
if self.__regex_from.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_to.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_subject.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_msgid.search(line): hd_obj.upd... | hd_obj.update(self.__regex_whitespaces.sub('', line)) | def hash_message_header(self, message): """Generate an sha1 checksum of the message header. """ hd_obj = sha.new() for line in message.splitlines(): if len(line) == 0: # only scan the header break if self.__regex_from.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_to.search(line):... |
return 'syslog' | return 'stderr' | def get_logger(self, account): """Return optional parameter logger. |
del self.__sha1_header_cache[folder][hd] def remove_leftover_messages(self): """Remove files, which are leftover from updating. """ | if len(self.__sha1_header_cache[folder][hd]) <= 1: del self.__sha1_header_cache[folder][hd] else: self.__sha1_header_cache[folder][hd] = self.__sha1_header_cache[folder][hd][1::] def remove_leftover(self): """Remove files or directories, which are leftover from updating. """ | def remove_from_index(self, folder, hd): """Remove index entry. """ if not folder.startswith(self.__basedir): folder = os.path.join(self.__basedir, folder) folder = folder.rstrip('/') |
flist = [folder] | flist = [] | def __get_folder_list(self, folder=None): """Return a list of valid mail folders. """ if folder == None: folder = self.__basedir if not folder.startswith(self.__basedir): folder = os.path.join(self.__basedir, folder) |
for logger in self.__config.get_logger(account).split(', '): | for logger in self.__config.get_logger(account).replace(' ', '').split(','): | def __config_logger(self, account): """Configures the logger singelton for the given account. """ Log().set_log_level(self.__config.get_log_level(account)) Log().remove_all_handlers() for logger in self.__config.get_logger(account).split(', '): if str.lower(logger) == 'syslog': Log().log_to_syslog() elif str.lower(logg... |
maildir.remove_leftover_messages() | maildir.remove_leftover() | def backup(self, account): try: self.__config_logger(account) maildir = Maildir(self.__config.get_maildir(account), True) imap = IMAP(self.__config.get_host(account), self.__config.get_port(account), self.__config.get_username(account), self.__config.get_password(account)) fo_filter = self.__config.get_imapfilter(acco... |
Log().error('imap error: ' % e) | Log().error('imap error: %s' % str(e)) | def backup(self, account): try: self.__config_logger(account) maildir = Maildir(self.__config.get_maildir(account), True) imap = IMAP(self.__config.get_host(account), self.__config.get_port(account), self.__config.get_username(account), self.__config.get_password(account)) fo_filter = self.__config.get_imapfilter(acco... |
Log().error('error: ' % e) | Log().error('error: %s' % str(e)) | def backup(self, account): try: self.__config_logger(account) maildir = Maildir(self.__config.get_maildir(account), True) imap = IMAP(self.__config.get_host(account), self.__config.get_port(account), self.__config.get_username(account), self.__config.get_password(account)) fo_filter = self.__config.get_imapfilter(acco... |
self.__formatter = logging.Formatter('imapbackup: %(message)s') | self.__syslog_formatter = logging.Formatter('%(name)s: [%(levelname)s] %(message)s') self.__file_formatter = logging.Formatter('%(asctime)s %(name)s: [%(levelname)s] %(message)s') | def __init__(self): self.__logger = logging.getLogger('imapbackup') self.__formatter = logging.Formatter('imapbackup: %(message)s') self.__handlers = [] |
handler.setFormatter(self.__formatter) | handler.setFormatter(self.__file_formatter) | def log_to_file(self, fname, exclusive=False): """Make the logger to log to a file. |
handler.setFormatter(self.__formatter) | handler.setFormatter(self.__syslog_formatter) | def log_to_syslog(self, exclusive=False): """Make the logger to log to syslog. |
["help", "account=", "config-file=", "list-folders"]) | ["help", "account=", "config-file=", "list-folders", "threads="]) | def __parse_cmdl(self): """ """ try: opts, args = getopt.getopt(sys.argv[1:], \ "ha:c:l", \ ["help", "account=", "config-file=", "list-folders"]) except getopt.GetoptError, e: print('error: %s' % e) self.__show_syntax() sys.exit(2) for opt, arg in opts: if opt in ("-h", "--help"): self.__show_syntax() sys.exit(3) elif ... |
for account in self.__config.get_accounts(): self.backup(account) | thr_max = self.__threads accounts = self.__config.get_accounts() if len(accounts) < thr_max: thr_max = len(accounts) class BackupThread(threading.Thread): def __init__(self, worker, account_list): threading.Thread.__init__(self) self.__worker = worker self.__account_list = account_list def run(self): for account in s... | def backup_all(self): for account in self.__config.get_accounts(): self.backup(account) |
self.__formatter = logging.Formatter('%(asctime)s %(message)s') | self.__formatter = logging.Formatter('imapbackup: %(message)s') | def __init__(self): self.__logger = logging.getLogger('imapbackup') self.__formatter = logging.Formatter('%(asctime)s %(message)s') self.__handlers = [] |
handler = logging.handlers.SysLogHandler() | handler = logging.handlers.SysLogHandler(address='/dev/log',\ facility=logging.handlers.SysLogHandler.LOG_SYSLOG) | def log_to_syslog(self, exclusive=False): """Make the logger to log to syslog. |
"ha:c:l:", \ | "ha:c:l", \ | def __parse_cmdl(self): """ """ try: opts, args = getopt.getopt(sys.argv[1:], \ "ha:c:l:", \ ["help", "account=", "config-file=", "list-folders"]) except getopt.GetoptError, e: print('error: %s' % e) self.__show_syntax() sys.exit(2) for opt, arg in opts: if opt in ("-h", "--help"): self.__show_syntax() sys.exit(3) elif... |
Log().set_log_level(self.__config.get_log_level(account)) | def __config_logger(self, account): """Configures the logger singelton for the given account. """ Log().remove_all_handlers() for logger in self.__config.get_logger(account).split(', '): if str.lower(logger) == 'syslog': Log().log_to_syslog() elif str.lower(logger) == 'file': Log().log_to_file(self.__config.get_log_fil... | |
def info(msg): if verbose: sys.stderr.write('info: ' + str(msg) + '\n') def warn(msg): sys.stderr.write('warning: ' + str(msg) + '\n') def error(msg): sys.exit('error: ' + str(msg)) class Configuration: def __init__(self, cfiles): self.__IMAPHOST = 'imapserver' self.__IMAPPORT = 'imapport' self.__IMAPUSER = 'imapuse... | class Log: def __call__(self): return self def __init__(self): self.__logger = logging.getLogger('imapbackup') self.__formatter = logging.Formatter('%(asctime)s %(message)s') self.__handlers = [] def __add_handler(self, handler): self.__logger.addHandler(handler) self.__handlers.append(handler) def set_log_level(sel... | def info(msg): if verbose: sys.stderr.write('info: ' + str(msg) + '\n') |
Utils = Utils() class Configuration: def __init__(self, cfiles): self.__IMAPHOST = 'imapserver' self.__IMAPPORT = 'imapport' self.__IMAPUSER = 'imapuser' self.__IMAPPASSWORD = 'imappassword' self.__IMAPFILTER = 'imapfilter' self.__IMAPSSL = 'imapssl' self.__MAILDIR = 'maildir' self.__LOGGER = 'logger' self.__LOGFILE... | def message_draft(self, flags): return self.__regex_msg_draft.match(flags) | |
error('can not connect to \'%s:%d\': %s' % (host, port, str(e))) | raise IMAPException('can not connect to \'%s:%d\': %s' % (host, port, str(e))) | def open(self, host, port, user, password, ssl=True): """Try to open the imap connection. """ try: if ssl: self.__connection = imaplib.IMAP4_SSL(host, port) else: self.__connection = imaplib.IMAP4(host, port) self.__connection.login(user, password) except Exception, e: error('can not connect to \'%s:%d\': %s' % (host, ... |
error('not connected to server!') | raise IMAPException('not connected to server!') | def __check_connection(self): """Check the imap connection. |
error('can not get folder list: %s' % str(e)) | raise IMAPException('can not get folder list: %s' % str(e)) | def get_folders(self, filter=None): """Return a list with all imap folders. """ self.__check_connection() ret = [] |
warn('imap.list() return: %s' % flist[0]) | Log().warn('imap.list() return: %s' % flist[0]) | def get_folders(self, filter=None): """Return a list with all imap folders. """ self.__check_connection() ret = [] |
warn('imap.search() return: %s' % flist[0]) utils = Utils() | Log().warn('imap.search() return: %s' % flist[0]) | def get_messages(self, folder): """Return a hash with all message uid's for the given folder. |
hd = utils.hash_message_header(data[0][1]).hexdigest() | hd = Utils().hash_message_header(data[0][1]).hexdigest() | def get_messages(self, folder): """Return a hash with all message uid's for the given folder. |
warn('imap.search() return: %s' % flist[0]) | Log().warn('imap.search() return: %s' % flist[0]) | def get_message(self, folder, uid): """Return the status and the message body for the given uid in the given folder. |
if create == True: if not os.path.isdir(self.__basedir): os.mkdir(self.__basedir) | try: if create == True: if not os.path.isdir(self.__basedir): os.mkdir(self.__basedir) except Exception, e: raise MaildirException('can not create basedir \'%s\': %s' % (self.__basedir, e)) if not os.path.isdir(self.__basedir): raise MaildirException('basedir \'%s\' does not exist' % self.__basedir) | def open(self, basedir, create=False): """Open the maildir folder and index all existing messages. |
utils = Utils() fname = utils.gen_filename() | fname = Utils().gen_filename() | def write_message(self, folder, message, flags): """Write a message in the given folder of the maildir. """ if not folder.startswith(self.__basedir): folder = os.path.join(self.__basedir, folder) utils = Utils() fname = utils.gen_filename() fname_tmp = os.path.join(folder, 'tmp', fname) |
if utils.message_seen(flags): fname_dst = os.path.join(folder, 'cur', fname + utils.gen_filename_aux(flags)) | if Utils().message_seen(flags): fname_dst = os.path.join(folder, 'cur', fname + Utils().gen_filename_aux(flags)) | def write_message(self, folder, message, flags): """Write a message in the given folder of the maildir. """ if not folder.startswith(self.__basedir): folder = os.path.join(self.__basedir, folder) utils = Utils() fname = utils.gen_filename() fname_tmp = os.path.join(folder, 'tmp', fname) |
fd = open(fname_tmp, 'w') fd.write(message) fd.close() | try: fd = open(fname_tmp, 'w') fd.write(message) fd.close() except Exception, e: raise MaildirException('can not write message \'%s\'' % fname_tmp) | def write_message(self, folder, message, flags): """Write a message in the given folder of the maildir. """ if not folder.startswith(self.__basedir): folder = os.path.join(self.__basedir, folder) utils = Utils() fname = utils.gen_filename() fname_tmp = os.path.join(folder, 'tmp', fname) |
info('[Maildir] write message "%s"' % fname_dst) | Log().debug('write message "%s"' % fname_dst) | def write_message(self, folder, message, flags): """Write a message in the given folder of the maildir. """ if not folder.startswith(self.__basedir): folder = os.path.join(self.__basedir, folder) utils = Utils() fname = utils.gen_filename() fname_tmp = os.path.join(folder, 'tmp', fname) |
def get_leftover_messages(self): """Return file names, which are leftover from updating. """ ret = [] | def remove_leftover_messages(self): """Remove files, which are leftover from updating. """ | def get_leftover_messages(self): """Return file names, which are leftover from updating. """ ret = [] for i in self.__sha1_header_cache.keys(): for j in self.__sha1_header_cache[i].keys(): for f in self.__sha1_header_cache[i][j]: ret.append(os.path.join(i, f)) return ret |
ret.append(os.path.join(i, f)) return ret | os.remove(os.path.join(i, f)) Log().debug('remove message "%s"' % os.path.join(i, f)) def __is_maildir_folder(self, folder): """Return True if the folder is a maildir folder. Test if the folder contains the three folders 'new', 'cur' and 'tmp'. """ if not folder.startswith(self.__basedir): folder = os.path.join(self.... | def get_leftover_messages(self): """Return file names, which are leftover from updating. """ ret = [] for i in self.__sha1_header_cache.keys(): for j in self.__sha1_header_cache[i].keys(): for f in self.__sha1_header_cache[i][j]: ret.append(os.path.join(i, f)) return ret |
for i in os.listdir(folder): if os.path.isdir(os.path.join(folder,i)) and i[0] == '.': flist.append(os.path.join(folder,i)) | for fo in os.listdir(folder): if os.path.isdir(os.path.join(folder,fo)) and self.__is_maildir_folder(fo): flist.append(os.path.join(folder,fo)) | def __get_folder_list(self, folder=None): if folder == None: folder = self.__basedir if not folder.startswith(self.__basedir): folder = os.path.join(self.__basedir, folder) |
for mdfolder in ['new', 'cur', 'tmp']: if os.path.isdir(os.path.join(folder, mdfolder)): for i in os.listdir(os.path.join(folder, mdfolder)): if os.path.isfile(os.path.join(folder, mdfolder, i)): mlist.append([mdfolder, i]) | try: for mdfolder in ['new', 'cur', 'tmp']: if os.path.isdir(os.path.join(folder, mdfolder)): for i in os.listdir(os.path.join(folder, mdfolder)): if os.path.isfile(os.path.join(folder, mdfolder, i)): mlist.append([mdfolder, i]) except Exception, e: raise MaildirException('can not get message list for folder \'%s\': %s... | def __get_message_list(self, folder): mlist = [] |
utils = Utils() | def __index_messages(self, folder=None): ret = {} | |
file = open(rfname, 'r') for line in file: if len(line) <= 2: break lines += line file.close() hd = utils.hash_message_header(lines).hexdigest() | try: file = open(rfname, 'r') for line in file: if len(line) <= 2: break lines += line file.close() except Exception, e: raise MaildirException('can not index message \'%s\': ' % (rfname, e)) hd = Utils().hash_message_header(lines).hexdigest() | def __index_messages(self, folder=None): ret = {} |
info('[Maildir] create folder "%s"' % folder) | Log().debug('create folder "%s"' % folder) | def __create_folder(self, folder): """Create an maildir folder if necessary. |
imap = IMAP(self.__config.get_host(account), self.__config.get_port(account), self.__config.get_username(account), self.__config.get_password(account), self.__config.use_imapssl(account)) filter = self.__config.get_imapfilter(account) for folder in imap.get_folders(filter): print '-> %s' % folder | try: self.__config_logger(account) imap = IMAP(self.__config.get_host(account), self.__config.get_port(account), self.__config.get_username(account), self.__config.get_password(account), self.__config.use_imapssl(account)) filter = self.__config.get_imapfilter(account) for folder in imap.get_folders(filter): print '->... | def list_imap_folders(self, account): imap = IMAP(self.__config.get_host(account), self.__config.get_port(account), self.__config.get_username(account), self.__config.get_password(account), self.__config.use_imapssl(account)) |
utils = Utils() maildir = Maildir(self.__config.get_maildir(account), True) imap = IMAP(self.__config.get_host(account), self.__config.get_port(account), self.__config.get_username(account), self.__config.get_password(account)) fo_filter = self.__config.get_imapfilter(account) for folder in imap.get_folders(fo_filter... | try: maildir = Maildir(self.__config.get_maildir(account), True) imap = IMAP(self.__config.get_host(account), self.__config.get_port(account), self.__config.get_username(account), self.__config.get_password(account)) fo_filter = self.__config.get_imapfilter(account) for folder in imap.get_folders(fo_filter): cf = mai... | def backup(self, account): utils = Utils() maildir = Maildir(self.__config.get_maildir(account), True) imap = IMAP(self.__config.get_host(account), self.__config.get_port(account), self.__config.get_username(account), self.__config.get_password(account)) fo_filter = self.__config.get_imapfilter(account) for folder in... |
w.backup_all() | def backup(self, account): utils = Utils() maildir = Maildir(self.__config.get_maildir(account), True) imap = IMAP(self.__config.get_host(account), self.__config.get_port(account), self.__config.get_username(account), self.__config.get_password(account)) fo_filter = self.__config.get_imapfilter(account) for folder in... | |
def checkfile (filename, strict = 1): | def checkfile (filename, strict = 1, typemap = {}): | def checkfile (filename, strict = 1): def expand (file, entry): |
def expand (file, entry): | def expand (file, entry, type = -1): | def expand (file, entry): |
items [k] = _bibtex.expand (file, items [k], -1) | items [k] = _bibtex.expand (file, items [k], typemap.get (k, -1)) | def expand (file, entry): |
'tests/paren.bib'): | 'tests/paren.bib', 'tests/url.bib'): | def expand (file, entry): |
f, c = checkfile (file) | f, c = checkfile (file, typemap = {'url': 4}) | def expand (file, entry): |
'tests/eof.bib'): | 'tests/eof.bib', 'tests/paren.bib'): | def expand (file, entry): |
if p == 'post': index = int(self.plotIndex.get()) | def Go(self): """Fit the current model.""" # Execute pre-callback if callable(self.preFitCallback): if not self.preFitCallback(): return # Write model text to tempfile self._tempName = tempfile.mktemp('.model') self.WriteModel(self._tempName) # Run clfit so we can grab its output optText = '' try: c = float(self.calErr... | |
optText += ' --plot post 1' | optText += ' --plot post %d' % index | def Go(self): """Fit the current model.""" # Execute pre-callback if callable(self.preFitCallback): if not self.preFitCallback(): return # Write model text to tempfile self._tempName = tempfile.mktemp('.model') self.WriteModel(self._tempName) # Run clfit so we can grab its output optText = '' try: c = float(self.calErr... |
optText += ' --zoomplot %s %d %.3f %.3f' % (p, index, xmin, xmax) | optText += ' --zoomplot post %d %.3f %.3f' % (index, xmin, xmax) | def Go(self): """Fit the current model.""" # Execute pre-callback if callable(self.preFitCallback): if not self.preFitCallback(): return # Write model text to tempfile self._tempName = tempfile.mktemp('.model') self.WriteModel(self._tempName) # Run clfit so we can grab its output optText = '' try: c = float(self.calErr... |
self.plots = ['No plot', 'vis2', 't3amp', 't3phi', 'post'] | self.plots = ['No plot', 'uv', 'vis2', 't3amp', 't3phi', 'vis2wl', 't3ampwl', 't3phiwl', 'post'] | def __init__(self, parent, dismissCommand=None): """Constructor. |
Label(calErrFrame, text='Calibration Error (extra frac. error in system vis.)').pack(side=LEFT, anchor=W) | Label(calErrFrame, text='Calibration Error (extra frac. error in system vis.) [NOT OIFITS]').pack(side=LEFT, anchor=W) | def __init__(self, parent, dismissCommand=None): """Constructor. |
pass | try: wlmin = float(self.wlmin.get()) wlmax = float(self.wlmax.get()) optText += ' --waverange %.2f %.2f' % (wlmin, wlmax) except ValueError: pass | def Go(self): """Fit the current model.""" # Execute pre-callback if callable(self.preFitCallback): if not self.preFitCallback(): return # Write model text to tempfile self._tempName = tempfile.mktemp('.model') self.WriteModel(self._tempName) # Run clfit so we can grab its output optText = '' try: c = float(self.calErr... |
def _main(): | def _main(altExe=None): | def _main(): """Main routine.""" # Find out if Python Megawidgets are installed try: import Pmw except ImportError: havePmw = 0 else: havePmw = 1 if len(sys.argv) == 1: # No command-line arguments - run graphical user interface root = Tk() if havePmw: Pmw.initialise(root, fontScheme='pmw1') root.title('fitgui %s' % _... |
'file:///usr/share/pixmaps/bt-logo.png', | icon_path, | def __init__(self, rem_path, dir_handle): |
name = '<Unkown>' | name = '<Unknown>' | def add_record(self,service_store,rec_path): |
name = dev['local_name'] | name = dev['name'] | def live_dev_cfg(self,dev): # # first of all, get status, if interface is down, just give up # self.updating = True |
self.widgets = gtk.glade.XML('bluetool-gui.glade', 'bt_cfg_wnd') | self.widgets = gtk.glade.XML('bluetool_gui.glade', 'bt_cfg_wnd') | def __init__(self): |
self.devclass_widgets = gtk.glade.XML('bluetool-gui.glade', 'bt_devclass_panel') | self.devclass_widgets = gtk.glade.XML('bluetool_gui.glade', 'bt_devclass_panel') | def __init__(self): |
name = dev['local_name'] | name = dev['name'] | def on_device_added(self,dev): addr = dev['address'] name = dev['local_name'] self.dev_liststore.append([dev.path, addr, name+"\t("+addr+")",False,False]); |
print "vfs_read_directory", handle, file_info, context | print "vfs_read_directory", handle, context | def vfs_read_directory(self, handle, file_info, context): print "vfs_read_directory", handle, file_info, context handle.read_dir(file_info) |
print "vfs_get_file_info", uri, file_info, options, context | print "vfs_get_file_info", uri, options, context | def vfs_get_file_info(self, uri, file_info, options, context): print "vfs_get_file_info", uri, file_info, options, context |
print "vfs_get_file_info_from_handle", handle, file_info, options, context | print "vfs_get_file_info_from_handle", handle, options, context | def vfs_get_file_info_from_handle(self, handle, file_info, options, context): print "vfs_get_file_info_from_handle", handle, file_info, options, context handle.get_file_info(file_info) |
print "------------------------> vfs_open", uri | print "vfs_open", uri | def vfs_open(self, uri, mode, context): print "------------------------> vfs_open", uri |
object which is a `Registry`_ instance. | object which is a Registry instance. | def cleanup(self): """Remove all objects from all StackedObjectProxy instances that were tracked at this Registry context""" for id, val in self.reglist[-1].iteritems(): stacked, obj = val stacked.pop_object(obj) self.reglist.pop() |
if (not self.force_content_type and (not content_type or not content_type.startswith('text/html'))): | if (removed or (not self.force_content_type and (not content_type or not content_type.startswith('text/html')))): | def __call__(self, environ, start_response): global _threadedprint_installed if environ.get('paste.testing'): # In a testing environment this interception isn't # useful: return self.app(environ, start_response) if not _threadedprint_installed: # @@: Not strictly threadsafe _threadedprint_installed = True threadedprint... |
output = capture_output(stats.print_stats, self.limit) output_callers = capture_output( stats.print_callers, self.limit) body += '<pre style="%s">%s\n%s</pre>' % ( self.style, cgi.escape(output), cgi.escape(output_callers)) | stats.print_stats(self.limit) stats.print_callers(self.limit) output = output.getvalue() body += '<pre style="%s">%s</pre>' % ( self.style, cgi.escape(output)) | def run_app(): body.extend(self.app(environ, replace_start_response)) |
def capture_output(func, *args, **kw): out = StringIO() old_stdout = sys.stdout sys.stdout = out try: func(*args, **kw) finally: sys.stdout = old_stdout return out.getvalue() | def run_app(): body.extend(self.app(environ, replace_start_response)) | |
output = capture_output(stats.print_stats, display_limit) output_callers = capture_output( stats.print_callers, display_limit) | stats.print_stats(display_limit) stats.print_callers(display_limit) | def profile(self, func, *args, **kw): ops = self.options prof_filename = ops.get('log_filename', 'profile_data.log.tmp') prof = hotshot.Profile(prof_filename) prof.addinfo('Function Call', self.format_function(func, *args, **kw)) if ops.get('add_info'): prof.addinfo('Extra info', ops['add_info']) exc_info = None try: s... |
f.write(output) f.write(output_callers) | f.write(output.getvalue()) | def profile(self, func, *args, **kw): ops = self.options prof_filename = ops.get('log_filename', 'profile_data.log.tmp') prof = hotshot.Profile(prof_filename) prof.addinfo('Function Call', self.format_function(func, *args, **kw)) if ops.get('add_info'): prof.addinfo('Extra info', ops['add_info']) exc_info = None try: s... |
self.files_created = {} | def __init__(self, test_env, args, stdin, stdout, stderr, returncode, files_before, files_after): self.test_env = test_env self.args = args self.stdin = stdin self.stdout = stdout self.stderr = stderr self.returncode = returncode self.files_before = files_before self.files_after = files_after self.files_created = {} se... | |
def __contain__(self, s): | def __contains__(self, s): | def __contain__(self, s): return s in self.bytes |
environ) | environ, view_uri) | def detect_start_response(status, headers, exc_info=None): try: return start_response(status, headers, exc_info) except: raise else: started.append(True) |
environ): | environ, view_uri): | def __init__(self, counter, exc_info, exc_data, base_path, environ): self.counter = counter self.exc_data = exc_data self.base_path = base_path self.environ = environ self.exc_type, self.exc_value, self.tb = exc_info __exception_formatter__ = 1 self.frames = [] n = 0 tb = self.tb while tb is not None and (limit is None... |
def setup_config(filename): conf = Config(with_default=True) conf.load(filename) if conf.get('sys_path'): update_sys_path(conf['sys_path'], conf['verbose']) from paste import CONFIG CONFIG.push_process_config(conf) return conf def update_sys_path(paths, verbose): if isinstance(paths, (str, unicode)): paths = [paths] f... | def convert_commandline(self, value): try: return int(value) except ValueError: pass return value | |
conf = self.__getconf() | conf = self.current_conf() | def __getattr__(self, attr): conf = self.__getconf() if not conf: raise AttributeError( "No configuration has been registered for this process " "or thread") return getattr(conf, attr) |
def __getconf(self): thread_configs = local_dict()[self._local_key] | def current_conf(self): thread_configs = local_dict().get(self._local_key) | def __getconf(self): thread_configs = local_dict()[self._local_key] if thread_configs: return thread_configs[-1] elif self._process_configs: return self._process_configs[-1] else: return None |
id = int(wsgilib.path_info_pop(environ)) | id = int(request.path_info_pop(environ)) if id not in self.debug_infos: start_response( '500 Server Error', [('Content-type', 'text/html')]) return [ "Traceback by id %s does not exist (maybe " "the server has been restarted?)" % id] | def view(self, environ, start_response): id = int(wsgilib.path_info_pop(environ)) debug_info = self.debug_infos[id] return debug_info.wsgi_application(environ, start_response) |
exc_data = collector.collect_exception(*exc_info) debug_info = DebugInfo(count, exc_info, exc_data, base_path, environ) assert count not in self.debug_infos self.debug_infos[count] = debug_info | def detect_start_response(status, headers, exc_info=None): try: return start_response(status, headers, exc_info) except: raise else: started.append(True) | |
required_headers = ('date',) | def location(self): for name, value in self.headers: if name.lower() == 'location': return value else: raise KeyError("No location set for %s" % self) | |
type = type.split(';', 1) | type = type.split(';', 1)[0] | def parse_formvars(environ, include_get_vars=True): """Parses the request, returning a MultiDict of form variables. If ``include_get_vars`` is true then GET (query string) variables will also be folded into the MultiDict. All values should be strings, except for file uploads which are left as FieldStorage instances. ... |
self.wfile = start_response | self.start = start_response self.body = [] | def __call__(self, environ, start_response): if environ['PATH_INFO'].startswith(self.auth_prefix): self.environ = environ self.wfile = start_response self.base_url = request.construct_url(environ) path = re.sub(auth_prefix, '', environ['PATH_INFO']) self.parsed_uri = urlparse.urlparse(path) self.query = dict(request.p... |
self.send_response(302) self.wfile.write(response) | response_headers = [('Content-type', 'text/html')] self.start(302, response_headers) return [response] | def redirect(self, redirect_url): """Send a redirect response to the given URL to the browser.""" response = """\ |
self.send_response(status) | response_headers = [('Content-type', 'text/html')] self.start(status, response_headers) | def render(self, message=None, css_class='alert', form_contents=None, status=200, title="Python OpenID Consumer Example"): """Render a page.""" self.send_response(status) self.pageHeader(title) if message: self.wfile.write("<div class='%s'>" % (css_class,)) self.wfile.write(message) self.wfile.write("</div>") self.page... |
self.wfile.write("<div class='%s'>" % (css_class,)) self.wfile.write(message) self.wfile.write("</div>") | self.body.append("<div class='%s'>" % (css_class,)) self.body.append(message) self.body.append("</div>") | def render(self, message=None, css_class='alert', form_contents=None, status=200, title="Python OpenID Consumer Example"): """Render a page.""" self.send_response(status) self.pageHeader(title) if message: self.wfile.write("<div class='%s'>" % (css_class,)) self.wfile.write(message) self.wfile.write("</div>") self.page... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.