我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用sys.tracebacklimit()。
def setUp(self): specialModuleFiles = {} callGraphBuilder = FromAssemblerCallGraphBuilder(ASSEMBLER_DIR, specialModuleFiles) self.sourceFiles = SourceFiles(SOURCE_DIR, specialModuleFiles); self.srcFile = SOURCE_DIR + '/recursion.f90' self.assFile = ASSEMBLER_DIR + '/recursion.s' self.filesExist = os.path.exists(self.srcFile) and os.path.exists(self.assFile) self.direct = SubroutineFullName('__recursion_MOD_recurse') self.callGraphDirect = callGraphBuilder.buildCallGraph(self.direct) self.indirect = SubroutineFullName('__recursion_MOD_indirect1') self.callGraphIndirect = callGraphBuilder.buildCallGraph(self.indirect) self.func = SubroutineFullName('__recursion_MOD_refunc') self.callGraphFunc = callGraphBuilder.buildCallGraph(self.func) self.position = SubroutineFullName('__recursion_MOD_position') self.callGraphPosition = callGraphBuilder.buildCallGraph(self.position) #sys.tracebacklimit = 0
def main(): parser = OptionParser(usage="$ python ./%prog [-u] url", version="%prog 1.0") parser.add_option("-u", "--url", dest="url", help="url to scan") parser.add_option("-d", action="store_true", dest="debug", help="turn on debug messages") (options, args) = parser.parse_args() if options.url == None: parser.print_help() exit(0) # debug switch if not options.debug: # show no traceback. Only exception sys.tracebacklimit = 0 global globalBaseUrl globalBaseUrl = options.url # initiate initiator(globalBaseUrl)
def main(): """ Main function. """ try: parser = get_parser() args = parser.parse_args() env = Environment(args.env) release = Release(args.release_id) sign = KojiSignRPMsInRelease(env, release, args.level, packages=args.packages, just_sign=args.just_sign, just_write=args.just_write) sign.run(commit=args.commit) except Error: if not args.debug: sys.tracebacklimit = 0 raise
def main(): """Main function.""" try: parser = get_parser() args = parser.parse_args() env = Environment(args.env) release_from = Release(args.from_release_id) release_to = Release(args.to_release_id) clone = PulpCloneRepos(env, release_from, release_to, args.repo_family, args.variants, args.arches, args.content_categories, args.skip_repo_check) clone.password_prompt(args.commit) clone.run(commit=args.commit) except Error: if not args.debug: sys.tracebacklimit = 0 raise
def extract_tb(tb, limit=None): """This implementation is stolen from traceback module but respects __traceback_hide__.""" if limit is None: if hasattr(sys, 'tracebacklimit'): limit = sys.tracebacklimit tb_list = [] n = 0 while tb is not None and (limit is None or n < limit): f = tb.tb_frame if not _should_skip_frame(f): lineno = tb.tb_lineno co = f.f_code filename = co.co_filename name = co.co_name linecache.checkcache(filename) line = linecache.getline(filename, lineno, f.f_globals) if line: line = line.strip() else: line = None tb_list.append((filename, lineno, name, line)) tb = tb.tb_next n = n + 1 return tb_list
def type_check(value, value_type, variable, override=None): """Check value is of type value_type, or is override""" sys.tracebacklimit = None # int_32 is an internal type so for the purpose of this external checking # it's OK to use the parent type (int). vtype = value_type if value_type == int_32: vtype = int if not isinstance(value, vtype) and value is not override: if override is not False: raise TypeError( "Expected {} or {} for {}, received {}".format(vtype, override, variable, type(value))) else: raise TypeError( "Expected {} for {}, received {}".format(vtype, variable, type(value))) return True
def value_check(value, min_value, max_value, variable, override=None): """Check if value is inside allowed range, or override""" sys.tracebacklimit = None if value != override and not ( (min_value is not None) and (min_value <= value) and (max_value is not None) and (value <= max_value)): if override is not False: raise ValueError( "Expected {} <= {} <= {} or {}, received {}".format( min_value, variable, max_value, override, value)) else: raise ValueError( "Expected {} <= {} <= {}, received {}".format( min_value, variable, max_value, value)) return True
def exit(self, message): """Exit the process and print an error message. Args: message (str): error message """ if hasattr(self, 'temp_dir') and self.paths['temp']: shutil.rmtree(self.paths['temp']) if not self.debug: sys.tracebacklimit = 0 raise ProgramEnd(message) # start _private methods
def print_tb(tb, limit=None, file=None): """Print up to 'limit' stack trace entries from the traceback 'tb'. If 'limit' is omitted or None, all entries are printed. If 'file' is omitted or None, the output goes to sys.stderr; otherwise 'file' should be an open file or file-like object with a write() method. """ if file is None: file = sys.stderr if limit is None: if hasattr(sys, 'tracebacklimit'): limit = sys.tracebacklimit n = 0 while tb is not None and (limit is None or n < limit): f = tb.tb_frame lineno = tb.tb_lineno co = f.f_code filename = co.co_filename name = co.co_name _print(file, ' File "%s", line %d, in %s' % (filename, lineno, name)) linecache.checkcache(filename) line = linecache.getline(filename, lineno, f.f_globals) if line: _print(file, ' ' + line.strip()) tb = tb.tb_next n = n+1
def extract_tb(tb, limit = None): """Return list of up to limit pre-processed entries from traceback. This is useful for alternate formatting of stack traces. If 'limit' is omitted or None, all entries are extracted. A pre-processed stack trace entry is a quadruple (filename, line number, function name, text) representing the information that is usually printed for a stack trace. The text is a string with leading and trailing whitespace stripped; if the source is not available it is None. """ if limit is None: if hasattr(sys, 'tracebacklimit'): limit = sys.tracebacklimit list = [] n = 0 while tb is not None and (limit is None or n < limit): f = tb.tb_frame lineno = tb.tb_lineno co = f.f_code filename = co.co_filename name = co.co_name linecache.checkcache(filename) line = linecache.getline(filename, lineno, f.f_globals) if line: line = line.strip() else: line = None list.append((filename, lineno, name, line)) tb = tb.tb_next n = n+1 return list
def extract_stack(f=None, limit = None): """Extract the raw traceback from the current stack frame. The return value has the same format as for extract_tb(). The optional 'f' and 'limit' arguments have the same meaning as for print_stack(). Each item in the list is a quadruple (filename, line number, function name, text), and the entries are in order from oldest to newest stack frame. """ if f is None: try: raise ZeroDivisionError except ZeroDivisionError: f = sys.exc_info()[2].tb_frame.f_back if limit is None: if hasattr(sys, 'tracebacklimit'): limit = sys.tracebacklimit list = [] n = 0 while f is not None and (limit is None or n < limit): lineno = f.f_lineno co = f.f_code filename = co.co_filename name = co.co_name linecache.checkcache(filename) line = linecache.getline(filename, lineno, f.f_globals) if line: line = line.strip() else: line = None list.append((filename, lineno, name, line)) f = f.f_back n = n+1 list.reverse() return list
def init_logger(): logging.basicConfig(filename="pjf_{0}.log".format(time.strftime("%d_%m_%Y")), level=PYJFUZZ_LOGLEVEL) logger = logging.getLogger(__name__) sys.tracebacklimit = 10 def handle_exception(exc_type, exc_value, exc_traceback): if issubclass(exc_type, KeyboardInterrupt): sys.__excepthook__(exc_type, exc_value, exc_traceback) return logger.error("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback)) sys.__excepthook__(exc_type, exc_value, None) return sys.excepthook = handle_exception return logger
def abort_and_print_credit(): if settings.CURRENT_JOB_HASH: abort_job(settings.CURRENT_JOB_HASH) print_time_credit(settings.CURRENT_JOB_HASH) sys.tracebacklimit = 0 sys.exit() # decorator that handles the possible errors
def add_error_handling(run_job_func): def wrap(*args, **kwargs): try: return run_job_func(*args, **kwargs) # all keyboard interrupt during streaming will be caught and raised as JobInterruptedException # anything here will be during upload or download, so we just abort except KeyboardInterrupt as e: print('\nJob aborted') abort_and_print_credit() # print('\nStreaming stopped, code is still running in the cloud') # print('Your job hash is: %s' % settings.CURRENT_JOB_HASH) except RequestFailedException as e: print('Oops, something went wrong...') print(e.error_msg) print('Please try again later') sys.tracebacklimit = 0 sys.exit() # except JobInterruptedException as e: # # extra newline incase no newline was printed # # print('\nJob interrupted') # # ans = input('Do you want to abort the job?\n') # # if ans == 'yes': # # abort_and_print_credit() # # else: # # print('Job is still running\n') # # print('To reconnect to the job:\n') # # print(' catalearn.reconnect()\n') # # print('To stop the job:\n') # # print(' catalearn.stop()\n') # print('Job aborted') # abort_and_print_credit() return wrap
def traceback_2(self): index = self.tb_preparation() print('Traceback (most recent call last):') print(''.join(traceback.format_stack()[:index])[:-1]) sys.tracebacklimit = 0
def traceback_3(self): index = self.tb_preparation() print('Traceback (most recent call last):') traceback.print_stack(limit=-index) sys.tracebacklimit = None ############################################################################## # TypeError session. ############################################################################## # ?????? # The argument(s) must be (a) number(s).
def extract_tb(tb, limit=None): """Return list of up to limit pre-processed entries from traceback. This is useful for alternate formatting of stack traces. If 'limit' is omitted or None, all entries are extracted. A pre-processed stack trace entry is a quadruple (filename, line number, function name, text) representing the information that is usually printed for a stack trace. The text is a string with leading and trailing whitespace stripped; if the source is not available it is None. """ if limit is None: if hasattr(sys, 'tracebacklimit'): limit = sys.tracebacklimit list = [] n = 0 while tb is not None and (limit is None or n < limit): f = tb.tb_frame lineno = tb.tb_lineno co = f.f_code filename = co.co_filename name = co.co_name linecache.checkcache(filename) line = linecache.getline(filename, lineno, f.f_globals) if line: line = line.strip() else: line = None list.append((filename, lineno, name, line)) tb = tb.tb_next n = n+1 return list
def extract_stack(f=None, limit=None): """Extract the raw traceback from the current stack frame. The return value has the same format as for extract_tb(). The optional 'f' and 'limit' arguments have the same meaning as for print_stack(). Each item in the list is a quadruple (filename, line number, function name, text), and the entries are in order from oldest to newest stack frame. """ if f is None: try: raise ZeroDivisionError except ZeroDivisionError: f = sys.exc_info()[2].tb_frame.f_back if limit is None: if hasattr(sys, 'tracebacklimit'): limit = sys.tracebacklimit list = [] n = 0 while f is not None and (limit is None or n < limit): lineno = f.f_lineno co = f.f_code filename = co.co_filename name = co.co_name linecache.checkcache(filename) line = linecache.getline(filename, lineno, f.f_globals) if line: line = line.strip() else: line = None list.append((filename, lineno, name, line)) f = f.f_back n = n+1 list.reverse() return list
def get_py_internals(): # noqa: D103 py_internals = [] if hasattr(sys, 'builtin_module_names'): py_internals.append(('Built-in Modules', ', '.join(sys.builtin_module_names))) py_internals.append(('Byte Order', sys.byteorder + ' endian')) if hasattr(sys, 'getcheckinterval'): py_internals.append(('Check Interval', sys.getcheckinterval())) if hasattr(sys, 'getfilesystemencoding'): py_internals.append(('File System Encoding', sys.getfilesystemencoding())) max_integer_size = str(sys.maxsize) + ' (%s)' % \ hex(sys.maxsize).upper() py_internals.append(('Maximum Integer Size', max_integer_size)) if hasattr(sys, 'getrecursionlimit'): py_internals.append(('Maximum Recursion Depth', sys.getrecursionlimit())) if hasattr(sys, 'tracebacklimit'): traceback_limit = sys.tracebacklimit else: traceback_limit = 1000 py_internals.append(('Maximum Traceback Limit', traceback_limit)) py_internals.append(('Maximum Code Point', sys.maxunicode)) return py_internals
def cli(debug): if debug: sys.tracebacklimit = 8
def test_debug(self, runner): runner.invoke(cli, ['-d']) assert sys.tracebacklimit == 8
def _raiseException(prefix, msg): sys.tracebacklimit = None raise(Exception('[OSMPythonTools.' + prefix + '] ' + msg))
