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] should be an error v_content = P.Optional(v_words_nonterminal) + dice | v_words v_phrase = Sup(o) + v_content + Sup(t) return v_phrase
|
|
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 = BigController(netmodel, d) bigview = BigView(bigctl) d.addCallback(finish).addErrback(finish) # FIXME reactor.callLater(1, _setServer, netmodel) reactor.run()
|
|
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 deferreds returned by this stack
|
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 deferreds returned by this stack
|
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.__regex_received = re.compile('^received: .*$', re.IGNORECASE) self.__regex_xorgto = re.compile('^x-original-to: .*$', re.IGNORECASE) self.__regex_delivto = re.compile('^delivered-to: .*$', re.IGNORECASE) self.__regex_returnpath = re.compile('^return-path: .*$', re.IGNORECASE)
|
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.IGNORECASE) self.__regex_received = re.compile('^received: .*$', re.IGNORECASE) self.__regex_xorgto = re.compile('^x-original-to: .*$', re.IGNORECASE) self.__regex_delivto = re.compile('^delivered-to: .*$', re.IGNORECASE) self.__regex_returnpath = re.compile('^return-path: .*$', re.IGNORECASE) self.__regex_msg_seen = re.compile('.*\Seen.*') self.__regex_msg_answerd = re.compile('.*\Answered.*') self.__regex_msg_flagged = re.compile('.*\Flagged.*') self.__regex_msg_deleted = re.compile('.*\Deleted.*') self.__regex_msg_draft = re.compile('.*\Draft.*') self.__regex_whitespaces = re.compile(' |\t')
|
|
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.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_date.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_received.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_xorgto.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_delivto.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_returnpath.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line))
|
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): 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.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_date.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_received.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_xorgto.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_delivto.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) elif self.__regex_returnpath.search(line): hd_obj.update(self.__regex_whitespaces.sub('', line)) return hd_obj
|
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(logger) == 'file': Log().log_to_file(self.__config.get_log_file(account))
|
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(account) for folder in imap.get_folders(fo_filter): # create folder if needed cf = maildir.create_folder(folder) mlist = imap.get_messages(folder) for uid, hhd in mlist.iteritems(): has_msg = maildir.has_message_header(folder, hhd) if cf or not has_msg: # folder was newly created and header not in maildir index # so save message flags, body = imap.get_message(folder, uid) maildir.write_message(folder, body, flags) else: maildir.remove_from_index(folder, hhd)
|
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(account) for folder in imap.get_folders(fo_filter): # create folder if needed cf = maildir.create_folder(folder) mlist = imap.get_messages(folder) for uid, hhd in mlist.iteritems(): has_msg = maildir.has_message_header(folder, hhd) if cf or not has_msg: # folder was newly created and header not in maildir index # so save message flags, body = imap.get_message(folder, uid) maildir.write_message(folder, body, flags) else: maildir.remove_from_index(folder, hhd)
|
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(account) for folder in imap.get_folders(fo_filter): # create folder if needed cf = maildir.create_folder(folder) mlist = imap.get_messages(folder) for uid, hhd in mlist.iteritems(): has_msg = maildir.has_message_header(folder, hhd) if cf or not has_msg: # folder was newly created and header not in maildir index # so save message flags, body = imap.get_message(folder, uid) maildir.write_message(folder, body, flags) else: maildir.remove_from_index(folder, hhd)
|
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 opt in ("-a", "--account"): self.__account = arg elif opt in ("-c", "--config-file"): self.__config_file = arg elif opt in ("-l", "--list-folders"): self.__list_folders = True
|
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 self.__account_list: self.__worker.backup(account) btlist = [] for thr_idx in range(thr_max): bt = BackupThread(self, accounts[thr_idx::thr_max]) bt.start() btlist.append(bt) for bt in btlist: bt.join()
|
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 opt in ("-a", "--account"): self.__account = arg elif opt in ("-c", "--config-file"): self.__config_file = arg elif opt in ("-l", "--list-folders"): self.__list_folders = True
|
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_file(account)) Log().set_log_level(self.__config.get_log_level(account))
|
|
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 = 'imapuser' self.__IMAPPASSWORD = 'imappassword' self.__IMAPFILTER = 'imapfilter' self.__IMAPSSL = 'imapssl' self.__MAILDIR = 'maildir' self.__cparser = ConfigParser.ConfigParser() if type(cfiles) != types.ListType: cfiles = [cfiles] def expand_user(path): return os.path.expanduser(path) self.__cparser.read(map(expand_user, cfiles)) def get_accounts(self): """Return list of all accounts. """ return self.__cparser.sections() def get_host(self, account): """Return imap host. """ try: return self.__cparser.get(account, self.__IMAPHOST) except: error('host for account %s not configured!' % account) def get_port(self, account): """Return optional imap port. default return value: 993 """ try: return int(self.__cparser.get(account, self.__IMAPPORT)) except: return 993 def get_username(self, account): """Return imap username. """ try: return self.__cparser.get(account, self.__IMAPUSER) except: error('username for account %s not configured!' % account) def get_password(self, account): """Return imap password. """ try: return self.__cparser.get(account, self.__IMAPPASSWORD) except: error('password for account %s not configured!' % account) def get_maildir(self, account): """Return maildir path. """ try: return self.__cparser.get(account, self.__MAILDIR) except: error('maildir for account %s not configured!' % account) def get_imapfilter(self, account): """Return optional imap filter string. default return value: None """ try: return self.__cparser.get(account, self.__IMAPFILTER) except: return None def use_imapssl(self, account): """Return True or False for optional parameter 'imapssl'. default return value: True """ try: if str.lower(self.__cparser.get(account, self.__IMAPSSL)) == 'false': return False else: return True except: return True
|
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(self, mode): """Set the logging level. Use logger.INFO, logger.WARN, logger.ERROR, ... """ self.__logger.setLevel(mode) def remove_all_handlers(self): """Remove all registered log handlers. """ for h in self.__handlers: self.__logger.removeHandler(h) self.__handlers = [] def log_to_file(self, fname, exclusive=False): """Make the logger to log to a file. If the parameter 'exclusive' is True, than all other log handlers are removed. """ if fname not in (''): if exclusive: self.remove_all_handlers() handler = logging.FileHandler(os.path.expanduser(fname)) handler.setFormatter(self.__formatter) self.__add_handler(handler) def log_to_syslog(self, exclusive=False): """Make the logger to log to syslog. If the parameter 'exclusive' is True, than all other log handlers are removed. """ if exclusive: self.remove_all_handlers() handler = logging.handlers.SysLogHandler() handler.setFormatter(self.__formatter) self.__add_handler(handler) def debug(self, msg): self.__logger.debug(msg) def info(self, msg): self.__logger.info(msg) def warn(self, msg): self.__logger.warn(msg) def error(self, msg): self.__logger.error(msg) def critical(self, msg): self.__logger.critical(msg) sys.exit() Log = Log()
|
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 = 'logfile' self.__LOGLEVEL = 'loglevel' self.__cparser = ConfigParser.ConfigParser() if type(cfiles) != types.ListType: cfiles = [cfiles] def expand_user(path): return os.path.expanduser(path) Log().debug('config files: %s' % map(expand_user, cfiles)) self.__cparser.read(map(expand_user, cfiles)) def get_accounts(self): """Return list of all accounts. """ return self.__cparser.sections() def get_host(self, account): """Return imap host. """ try: return self.__cparser.get(account, self.__IMAPHOST) except: Log().critical('host for account %s not configured!' % account) def get_port(self, account): """Return optional parameter imap port. default return value: 993 """ try: return int(self.__cparser.get(account, self.__IMAPPORT)) except: return 993 def get_username(self, account): """Return imap username. """ try: return self.__cparser.get(account, self.__IMAPUSER) except: Log().critical('username for account %s not configured!' % account) def get_password(self, account): """Return imap password. """ try: return self.__cparser.get(account, self.__IMAPPASSWORD) except: Log().critical('password for account %s not configured!' % account) def get_maildir(self, account): """Return maildir path. """ try: return self.__cparser.get(account, self.__MAILDIR) except: Log().critical('maildir for account %s not configured!' % account) def get_imapfilter(self, account): """Return optional imap filter string. default return value: None """ try: return self.__cparser.get(account, self.__IMAPFILTER) except: return None def use_imapssl(self, account): """Return True or False for optional parameter 'imapssl'. default return value: True """ try: if str.lower(self.__cparser.get(account, self.__IMAPSSL)) == 'false': return False else: return True except: return True def get_logger(self, account): """Return optional parameter logger. default return value: none """ try: return self.__cparser.get(account, self.__LOGGER) except: return 'syslog' def get_log_file(self, account): """Return file to log to. """ try: return self.__cparser.get(account, self.__LOGFILE) except: Log().critical('logfile for account %s not configured!' % account) def get_log_level(self, account): """Return optional parameter log level. default return value: logger.ERROR """ try: lvl = str.lower(self.__cparser.get(account, self.__LOGLEVEL)) if lvl == 'debug': return logging.DEBUG elif lvl == 'info': return logging.INFO elif lvl == 'warning': return logging.WARNING elif lvl == 'error': return logging.ERROR elif lvl == 'critical': return logging.CRITICAL except: return logging.ERROR class IMAPException(Exception): pass
|
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, port, str(e)))
|
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.__basedir, folder) return os.path.isdir(os.path.join(folder, 'new')) and \ os.path.isdir(os.path.join(folder, 'cur')) and \ os.path.isdir(os.path.join(folder, 'tmp'))
|
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' % (folder, e))
|
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 '-> %s' % folder except IMAPException, e: Log().error('imap error: ' % e) except: Log().error('error: ' % e)
|
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): cf = maildir.create_folder(folder) mlist = imap.get_messages(folder) for uid, hhd in mlist.iteritems(): has_msg = maildir.has_message_header(folder, hhd) if cf or not has_msg: flags, body = imap.get_message(folder, uid) maildir.write_message(folder, body, flags) else: maildir.remove_from_index(folder, hhd) for fname in maildir.get_leftover_messages(): info('[Worker] remove message "%s"' % fname) os.remove(fname)
|
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 = maildir.create_folder(folder) mlist = imap.get_messages(folder) for uid, hhd in mlist.iteritems(): has_msg = maildir.has_message_header(folder, hhd) if cf or not has_msg: flags, body = imap.get_message(folder, uid) maildir.write_message(folder, body, flags) else: maildir.remove_from_index(folder, hhd) maildir.remove_leftover_messages() except IMAPException, e: Log().error('imap error: ' % e) except: Log().error('error: ' % e)
|
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 imap.get_folders(fo_filter): # create folder if needed cf = maildir.create_folder(folder) mlist = imap.get_messages(folder) for uid, hhd in mlist.iteritems(): has_msg = maildir.has_message_header(folder, hhd) if cf or not has_msg: # folder was newly created and header not in maildir index # so save message flags, body = imap.get_message(folder, uid) maildir.write_message(folder, body, flags) else: maildir.remove_from_index(folder, hhd)
|
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 imap.get_folders(fo_filter): # create folder if needed cf = maildir.create_folder(folder) mlist = imap.get_messages(folder) for uid, hhd in mlist.iteritems(): has_msg = maildir.has_message_header(folder, hhd) if cf or not has_msg: # folder was newly created and header not in maildir index # so save message flags, body = imap.get_message(folder, uid) maildir.write_message(folder, body, flags) else: maildir.remove_from_index(folder, hhd)
|
|
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.get()) except ValueError: pass else: optText += ' --calerr %.3f' % c try: cwl = float(self.cwl.get()) bw = float(self.bw.get()) except ValueError: pass else: optText += ' --waveband %.2f %.2f' % (cwl, bw) p = self.selPlot.get() if p != self.plots[0]: # not 'No plot' try: if p == 'post': index = int(self.plotIndex.get()) xmin = float(self.plotFrom.get()) xmax = float(self.plotTo.get()) except ValueError: if p == 'post': optText += ' --plot post 1' else: optText += ' --plot %s' % p else: if p == 'post': optText += ' --zoomplot %s %d %.3f %.3f' % (p, index, xmin, xmax) else: optText += ' --zoomplot %s %.3f %.3f' % (p, xmin, xmax) if self.nofit.get(): optText += ' --nofit' command = '%s%s --device %s %s %s' % ( self.exe, optText, self.device, self.fileName.get(), self._tempName) self.ShowResult('Running %s:\n' % command, tag='commentary') self._popen4 = popen2.Popen4(command, 10) fd = self._popen4.fromchild.fileno() # stdout & stderr of child process oldflags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, oldflags|os.O_NONBLOCK) tkinter.createfilehandler(fd, READABLE, self._DisplayOutput)
|
|
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.get()) except ValueError: pass else: optText += ' --calerr %.3f' % c try: cwl = float(self.cwl.get()) bw = float(self.bw.get()) except ValueError: pass else: optText += ' --waveband %.2f %.2f' % (cwl, bw) p = self.selPlot.get() if p != self.plots[0]: # not 'No plot' try: if p == 'post': index = int(self.plotIndex.get()) xmin = float(self.plotFrom.get()) xmax = float(self.plotTo.get()) except ValueError: if p == 'post': optText += ' --plot post 1' else: optText += ' --plot %s' % p else: if p == 'post': optText += ' --zoomplot %s %d %.3f %.3f' % (p, index, xmin, xmax) else: optText += ' --zoomplot %s %.3f %.3f' % (p, xmin, xmax) if self.nofit.get(): optText += ' --nofit' command = '%s%s --device %s %s %s' % ( self.exe, optText, self.device, self.fileName.get(), self._tempName) self.ShowResult('Running %s:\n' % command, tag='commentary') self._popen4 = popen2.Popen4(command, 10) fd = self._popen4.fromchild.fileno() # stdout & stderr of child process oldflags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, oldflags|os.O_NONBLOCK) tkinter.createfilehandler(fd, READABLE, self._DisplayOutput)
|
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.get()) except ValueError: pass else: optText += ' --calerr %.3f' % c try: cwl = float(self.cwl.get()) bw = float(self.bw.get()) except ValueError: pass else: optText += ' --waveband %.2f %.2f' % (cwl, bw) p = self.selPlot.get() if p != self.plots[0]: # not 'No plot' try: if p == 'post': index = int(self.plotIndex.get()) xmin = float(self.plotFrom.get()) xmax = float(self.plotTo.get()) except ValueError: if p == 'post': optText += ' --plot post 1' else: optText += ' --plot %s' % p else: if p == 'post': optText += ' --zoomplot %s %d %.3f %.3f' % (p, index, xmin, xmax) else: optText += ' --zoomplot %s %.3f %.3f' % (p, xmin, xmax) if self.nofit.get(): optText += ' --nofit' command = '%s%s --device %s %s %s' % ( self.exe, optText, self.device, self.fileName.get(), self._tempName) self.ShowResult('Running %s:\n' % command, tag='commentary') self._popen4 = popen2.Popen4(command, 10) fd = self._popen4.fromchild.fileno() # stdout & stderr of child process oldflags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, oldflags|os.O_NONBLOCK) tkinter.createfilehandler(fd, READABLE, self._DisplayOutput)
|
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.get()) except ValueError: pass else: optText += ' --calerr %.3f' % c try: cwl = float(self.cwl.get()) bw = float(self.bw.get()) except ValueError: pass else: optText += ' --waveband %.2f %.2f' % (cwl, bw) p = self.selPlot.get() if p != self.plots[0]: # not 'No plot' if p == 'post': try: index = int(self.plotIndex.get()) except ValueError: index = 1 try: xmin = float(self.plotFrom.get()) xmax = float(self.plotTo.get()) except ValueError: if p == 'post': optText += ' --plot post %d' % index else: optText += ' --plot %s' % p else: if p == 'post': optText += ' --zoomplot post %d %.3f %.3f' % (index, xmin, xmax) else: optText += ' --zoomplot %s %.3f %.3f' % (p, xmin, xmax) if self.nofit.get(): optText += ' --nofit' command = '%s%s --device %s %s %s' % ( self.exe, optText, self.device, self.fileName.get(), self._tempName) self.ShowResult('Running %s:\n' % command, tag='commentary') self._popen4 = popen2.Popen4(command, 10) fd = self._popen4.fromchild.fileno() # stdout & stderr of child process oldflags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, oldflags|os.O_NONBLOCK) tkinter.createfilehandler(fd, READABLE, self._DisplayOutput)
|
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' % _revision) main = GUI(root) #main.fileName.set('/net/oberon/home/jsy1001/reductions/alp_ori_02/alp_ori_0203-04_corr2.mapdat') #main.ReadModel('/net/oberon/home/jsy1001/reductions/alp_ori_02/alpOri.model') root.mainloop() else: # Too many arguments print "%s %s\n" % (sys.argv[0], _revision) print __doc__ sys.exit(2)
|
'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.install(leave_stdout=True) logged = StringIO() if self.print_wsgi_errors: replacement_stdout = TeeFile(environ['wsgi.errors'], logged) else: replacement_stdout = logged output = StringIO() try: threadedprint.register(replacement_stdout) status, headers, body = wsgilib.intercept_output( environ, self.app) if status is None: # Some error occurred status = '500 Server Error' headers = [('Content-type', 'text/html')] start_response(status, headers) if not body: body = 'An error occurred' content_type = response.header_value(headers, 'content-type') if (not self.force_content_type and (not content_type or not content_type.startswith('text/html'))): if replacement_stdout == logged: # Then the prints will be lost, unless... environ['wsgi.errors'].write(logged.getvalue()) start_response(status, headers) return [body] response.remove_header(headers, 'content-length') body = self.add_log(body, logged.getvalue()) start_response(status, headers) return [body] finally: threadedprint.deregister()
|
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: start_time = time.time() try: result = prof.runcall(func, *args, **kw) except: exc_info = sys.exc_info() end_time = time.time() finally: prof.close() stats = hotshot.stats.load(prof_filename) os.unlink(prof_filename) if ops.get('strip_dirs', True): stats.strip_dirs() stats.sort_stats(*ops.get('sort_stats', ('time', 'calls'))) display_limit = ops.get('display_limit', 20) output = capture_output(stats.print_stats, display_limit) output_callers = capture_output( stats.print_callers, display_limit) output_file = ops.get('log_file') if output_file in (None, 'stderr'): f = sys.stderr elif output_file in ('-', 'stdout'): f = sys.stdout else: f = open(output_file, 'a') f.write('\n%s\n' % ('-'*60)) f.write('Date: %s\n' % time.strftime('%c')) f.write('Function call: %s\n' % self.format_function(func, *args, **kw)) f.write('Wall time: %0.2f seconds\n' % (end_time - start_time)) f.write(output) f.write(output_callers) if output_file not in (None, '-', 'stdout', 'stderr'): f.close() if exc_info: # We captured an exception earlier, now we re-raise it raise exc_info[0], exc_info[1], exc_info[2] return result
|
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: start_time = time.time() try: result = prof.runcall(func, *args, **kw) except: exc_info = sys.exc_info() end_time = time.time() finally: prof.close() stats = hotshot.stats.load(prof_filename) os.unlink(prof_filename) if ops.get('strip_dirs', True): stats.strip_dirs() stats.sort_stats(*ops.get('sort_stats', ('time', 'calls'))) display_limit = ops.get('display_limit', 20) output = capture_output(stats.print_stats, display_limit) output_callers = capture_output( stats.print_callers, display_limit) output_file = ops.get('log_file') if output_file in (None, 'stderr'): f = sys.stderr elif output_file in ('-', 'stdout'): f = sys.stdout else: f = open(output_file, 'a') f.write('\n%s\n' % ('-'*60)) f.write('Date: %s\n' % time.strftime('%c')) f.write('Function call: %s\n' % self.format_function(func, *args, **kw)) f.write('Wall time: %0.2f seconds\n' % (end_time - start_time)) f.write(output) f.write(output_callers) if output_file not in (None, '-', 'stdout', 'stderr'): f.close() if exc_info: # We captured an exception earlier, now we re-raise it raise exc_info[0], exc_info[1], exc_info[2] return result
|
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 = {} self.files_deleted = {} self.files_updated = {} self.files_created = files_after.copy() for path, f in files_before.items(): if path not in files_after: self.files_deleted[path] = f continue del self.files_created[path] if f.mtime < files_after[path].mtime: self.files_updated[path] = files_after[path]
|
|
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 or n < limit): if tb.tb_frame.f_locals.get('__exception_formatter__'): # Stop recursion. @@: should make a fake ExceptionFrame break self.frames.append(tb) tb = tb.tb_next n += 1
|
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] for path in paths: path = os.path.abspath(path) if path not in sys.path: if verbose: print 'Adding %s to path' % path sys.path.insert(0, path)
|
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. If the request was not a normal form request (e.g., a POST with an XML body) then ``environ['wsgi.input']`` won't be read. """ source = environ['wsgi.input'] if 'paste.parsed_formvars' in environ: parsed, check_source = environ['paste.parsed_formvars'] if check_source == source: if include_get_vars: parsed.update(parse_querystring(environ)) return parsed # @@: Shouldn't bother FieldStorage parsing during GET/HEAD and # fake_out_cgi requests type = environ.get('CONTENT_TYPE', '').lower() if ';' in type: type = type.split(';', 1) fake_out_cgi = (type not in ('', 'application/x-www-form-urlencoded') and not type.startswith('multipart/form-data')) # Prevent FieldStorage from parsing QUERY_STRING during GET/HEAD # requests old_query_string = environ.get('QUERY_STRING','') environ['QUERY_STRING'] = '' if fake_out_cgi: input = StringIO('') old_content_type = environ.get('CONTENT_TYPE') old_content_length = environ.get('CONTENT_LENGTH') environ['CONTENT_LENGTH'] = '0' environ['CONTENT_TYPE'] = '' else: input = environ['wsgi.input'] fs = cgi.FieldStorage(fp=input, environ=environ, keep_blank_values=1) environ['QUERY_STRING'] = old_query_string if fake_out_cgi: environ['CONTENT_TYPE'] = old_content_type environ['CONTENT_LENGTH'] = old_content_length formvars = MultiDict() if isinstance(fs.value, list): for name in fs.keys(): values = fs[name] if not isinstance(values, list): values = [values] for value in values: if not value.filename: value = value.value formvars.add(name, value) environ['paste.parsed_formvars'] = (formvars, source) if include_get_vars: formvars.update(parse_querystring(environ)) return formvars
|
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.parse_querystring(environ)) path = self.parsed_uri[2] if path == '/': self.render() elif path == '/verify': self.doVerify() elif path == '/process': self.doProcess() else: self.notFound() else: return self.app(environ, start_response)
|
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.pageFooter(form_contents)
|
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.pageFooter(form_contents)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.