def test_locals(self):
linecache.updatecache('/foo.py', globals())
e = Exception("uh oh")
c = test_code('/foo.py', 'method')
f = test_frame(c, globals(), {'something': 1, 'other': 'string'})
tb = test_tb(f, 6, None)
exc = traceback.TracebackException(Exception,
e,
tb,
capture_locals=True)
self.assertEqual(exc.stack[0].locals, {
'something': '1',
'other': "'string'"
})
def with_traceback(self,
exc_info=None,
traceback_exception=None) -> 'JsonRpcError':
if not traceback_exception:
traceback_exception = traceback.TracebackException(*sys.exc_info())
if self.data is None:
self.data = {}
if isinstance(self.data, dict):
self.data['traceback_exception'] = ''.join(
traceback_exception.format()).split("\n")
return self
def test_smoke(self):
try:
1 / 0
except Exception:
exc_info = sys.exc_info()
exc = traceback.TracebackException(*exc_info)
expected_stack = traceback.StackSummary.extract(
traceback.walk_tb(exc_info[2]))
self.assertEqual(None, exc.__cause__)
self.assertEqual(None, exc.__context__)
self.assertEqual(False, exc.__suppress_context__)
self.assertEqual(expected_stack, exc.stack)
self.assertEqual(exc_info[0], exc.exc_type)
self.assertEqual(str(exc_info[1]), str(exc))
def test_limit(self):
def recurse(n):
if n:
recurse(n-1)
else:
1/0
try:
recurse(10)
except Exception:
exc_info = sys.exc_info()
exc = traceback.TracebackException(*exc_info, limit=5)
expected_stack = traceback.StackSummary.extract(
traceback.walk_tb(exc_info[2]), limit=5)
self.assertEqual(expected_stack, exc.stack)
def StartMining():
'''
actions.Undock()
time.sleep(15)
actions.WarpToPoint('Mine')
time.sleep(15)
while WarpDriveActive():
time.sleep(5)
'''
#Came to mining site -------------
#Init equipment
shield = equipment.Shield()
scanner = equipment.Scanner()
drones = equipment.Drones()
lasers = []
lasers.append(equipment.Laser(0))
lasers.append(equipment.Laser(1))
ore_hold = equipment.OreHold(5000)
current_asteroids = []
#---------------------------------
'''
shield.Engage()
drones.Engage()
'''
while True: #not ore_hold.IsFull():
lasers = LasersNeedToRepeat(lasers)
lasersCount = len(lasers)
if lasersCount > 0:
try:
current_asteroids = actions.GetOreNearby('Kernite', 2, 10000, 100, current_asteroids)
for i, asteroid in enumerate(current_asteroids[:lasersCount]):
actions.CloseScannerTabs()
lasers[i].Engage(asteroid)
#actions.CloseScanPanel()
time.sleep(10)
except Exception as err:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = traceback.TracebackException(
exc_type, exc_value, exc_tb,
)
print(''.join(tbe.format()))
print('\nexception only:')
print(''.join(tbe.format_exception_only()))
finally:
print('stop here')
def CalShanon(stkfile):
logid = scriptname + '.CalShanon: '
try:
aligEnt = 0
nameOffile = stkfile
listofchars = [] #use as temp to count nucleotides at each site
listofsites = [
] #use to store the ratio of each nucleotide at each site, i filled it as list of list
lengseq = 0 #lenght of sequence, NOTE: all should be same
numofseqs = 0
#loop to initialize nucleotides' list to zero
for i in range(0, 5):
listofchars.append(0)
#Fill the list of sites with the ratios of nucleotides
alignment = AlignIO.read(nameOffile, "stockholm")
for record1 in alignment:
numofseqs += 1
recid1 = record1.id
seqi = str(record1.seq)
lengseq = len(seqi)
SeqEachSite = []
EntEachSite = []
for i in range(0, lengseq):
EntEachSite.append("")
SeqEachSite.append("")
for record in alignment:
seqtemp = str(record.seq)
for i in range(0, lengseq):
SeqEachSite[i] = SeqEachSite[i] + seqtemp[i]
for i in range(0, lengseq):
EntEachSite = cal_ent(SeqEachSite[i])
aligEnt = aligEnt + EntEachSite
return aligEnt
except Exception:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type,
exc_value,
exc_tb,
)
log.error(logid + ''.join(tbe.format()))
def format_filtered_stacktrace(filter_traceback='default'):
"""
Returns the traceback as `string`.
`filter_traceback` can be one of:
- 'always': always filter out sacred internals
- 'default': Default behaviour: filter out sacred internals
if the exception did not originate from within sacred, and
print just the internal stack trace otherwise
- 'never': don't filter, always print full traceback
- All other values will fall back to 'never'.
"""
exc_type, exc_value, exc_traceback = sys.exc_info()
# determine if last exception is from sacred
current_tb = exc_traceback
while current_tb.tb_next is not None:
current_tb = current_tb.tb_next
if filter_traceback == 'default' \
and _is_sacred_frame(current_tb.tb_frame):
# just print sacred internal trace
header = ["Exception originated from within Sacred.\n"
"Traceback (most recent calls):\n"]
texts = tb.format_exception(exc_type, exc_value, current_tb)
return ''.join(header + texts[1:]).strip()
elif filter_traceback in ('default', 'always'):
# print filtered stacktrace
if sys.version_info >= (3, 5):
tb_exception = \
tb.TracebackException(exc_type, exc_value, exc_traceback,
limit=None)
return ''.join(filtered_traceback_format(tb_exception))
else:
s = "Traceback (most recent calls WITHOUT Sacred internals):"
current_tb = exc_traceback
while current_tb is not None:
if not _is_sacred_frame(current_tb.tb_frame):
tb.print_tb(current_tb, 1)
current_tb = current_tb.tb_next
s += "\n".join(tb.format_exception_only(exc_type,
exc_value)).strip()
return s
elif filter_traceback == 'never':
# print full stacktrace
return '\n'.join(
tb.format_exception(exc_type, exc_value, exc_traceback))
else:
raise ValueError('Unknown value for filter_traceback: ' +
filter_traceback)
def handle(self, *args, **options):
self.stdout.write(self.style.SUCCESS("Starting izumi-ng reader."))
try:
g.application = app = Application()
app.start()
except Exception as e:
self.stdout.write(
f"Error while starting izumi-ng reader, error: {e}")
import sys, traceback
full_err = ''.join(
traceback.TracebackException(*sys.exc_info()).format())
self.stdout.write(f"Full error below:\n {full_err}")
def isinvalid(x=None):
try:
if x:
if x in ('None', 'nan', 'none', 'NA', 'NAN') or x is None or x is np.nan:
return True
else:
return False
else:
return True
except Exception as err:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type, exc_value, exc_tb,
)
clog.error(logid+''.join(tbe.format()))
def serializable_error_info_from_exc_info(
exc_info: Union[Tuple[Type[BaseException], BaseException, TracebackType],
Tuple[None, None, None]],
# Whether to forward serialized errors thrown from subprocesses
hoist_user_code_error: Optional[bool] = True,
) -> SerializableErrorInfo:
_exc_type, e, _tb = exc_info
from dagster.core.errors import DagsterUserCodeProcessError
if (hoist_user_code_error and isinstance(e, DagsterUserCodeProcessError)
and len(e.user_code_process_error_infos) == 1):
return e.user_code_process_error_infos[0]
else:
return _serializable_error_info_from_tb(
traceback.TracebackException(*exc_info))
def _map_func(dat):
try:
ret = self.extractor.transform(dat)
except Exception as e: # Non-handled exception
ret = '\n========\n'
ret += 'Time : `%s`\n' % str(
get_formatted_datetime(only_number=False))
ret += 'Error : `%s`\n' % str(e)
ret += 'Input : `%s`\n' % str(dat)
import traceback
etype, value, tb = sys.exc_info()
for line in traceback.TracebackException(
type(value), value, tb, limit=None).format(chain=True):
ret += line
return ret
def create_log_entry_by_record(self, record):
"""Create log entry by `logging.LogRecord`"""
if record.name == 'celery.app.trace':
# Remove celery task id, to make same errors match
record.args['id'] = ''
log_hash = hashlib.md5(
str(' '.join(
str(x) for x in [
record.pathname,
record.lineno,
record.getMessage(),
])).encode()).hexdigest()
log, _ = self.get_or_create(log_hash=log_hash,
defaults={
'level': record.levelno,
'message': record.getMessage(),
'file_path': record.pathname,
'file_line': record.lineno,
'last_event': timezone.now(),
})
if record.exc_info and not log.traceback:
log.traceback = ''.join(
traceback.TracebackException(*record.exc_info).format())
if not record.exc_info and not log.traceback:
# Create traceback and remove last items from log library
new_trace = 'Traceback stack (with the logging removed):\n'
for line in traceback.format_stack():
if '/logging/__init__.py' in line:
break
new_trace += line
log.traceback = new_trace
request = get_current_request()
entry = LogEntry.objects.create(
log=log,
log_time=timezone.now(),
user=request.user
if request and not request.user.is_anonymous else None,
path=request.path if request else '',
user_agent=request.META.get('HTTP_USER_AGENT') if request else '',
)
log.last_event = entry.log_time
log.log_count = log.entries.count()
log.save()
def internal_server_error_view(request):
try:
etype, value, tb = sys.exc_info()
output = []
django_dir = os.path.dirname(django.__file__)
site_packages = os.path.dirname(django_dir)
kasse_dir = os.path.dirname(os.path.dirname(kasse.__file__))
repos = [
(django_dir, site_packages, "django/django", "2.2.3"),
(kasse_dir, kasse_dir, "TK-IT/kasse", "master"),
]
for part in traceback.TracebackException(etype, value, tb).format():
mo = re.match(r'^( File "(.*)", line (\d+).*\n)(.*\n)((?:.|\n)*)',
part)
if not mo:
output.append(part)
continue
line1, filename, lineno, line2, line3 = mo.groups()
for project_dir, strip_dir, project, version in repos:
if not filename.startswith(project_dir):
continue
relpath = filename.replace(strip_dir, "")
url = "https://github.com/%s/blob/%s%s#L%s" % (
project,
version,
relpath,
lineno,
)
output.append(line1.replace(strip_dir, "..."))
output.append(
format_html(
' <a href="{}" target="_blank" rel="noopener">{}</a>\n',
url,
line2.strip(),
))
break
else:
output.append(line1)
output.append(line2)
if line3:
output.append(line3)
return SimpleTemplateResponse("http500.html",
context={"traceback": output},
status=500)
except Exception:
tb = traceback.format_exc()
return HttpResponseServerError("Server Error (500)\n\n" + tb,
content_type="text/plain")
def readin(file):
try:
if ".gz" in file:
f = gzip.open(file, "rt")
else:
f = open(file, "rt")
return f
except Exception:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type,
exc_value,
exc_tb,
)
print("".join(tbe.format()), file=sys.stderr)
def convertcol(entry):
logid = scriptname + '.convertcol: '
try:
if isinvalid(entry):
# if entry is None or entry == 'NA' or entry == 'nan' or entry is np.nan:
return np.nan
else:
return float(entry)
except Exception:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type,
exc_value,
exc_tb,
)
log.error(logid + ''.join(tbe.format()))
def makeoutdir(outdir):
logid = scriptname + '.makeoutdir: '
try:
if not os.path.isabs(outdir):
outdir = os.path.abspath(outdir)
if not os.path.exists(outdir):
os.makedirs(outdir)
return outdir
except Exception:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type,
exc_value,
exc_tb,
)
log.error(logid + ''.join(tbe.format()))
def print_exception_without_first_line(etype,
value,
tb,
limit=None,
file=None,
chain=True):
if file is None:
file = sys.stderr
lines = iter(
traceback.TracebackException(type(value), value, tb,
limit=limit).format(chain=chain))
next(lines)
for line in lines:
print(line, file=file, end="")
def parse_bam(bam):
try:
if '.bam' in bam:
return pysam.AlignmentFile(bam, "rb")
elif '.sam' in bam:
if '.gz' in bam[-4:]:
return pysam.AlignmentFile(gzip.open(bam,'rt'), "r")
else:
return pysam.AlignmentFile(bam, "r")
except Exception as err:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type, exc_value, exc_tb,
)
with open('error','a') as h:
print(''.join(tbe.format()), file=h)
def readin(file):
try:
if '.gz' in file:
f = gzip.open(file, 'rt')
else:
f = open(file, 'rt')
return f
except Exception as err:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type,
exc_value,
exc_tb,
)
print(''.join(tbe.format()), file=sys.stderr)
def wrapper(*args, **kwargs):
try:
val = func(*args, **kwargs)
exc = None
tb = None
tb_class = None
except Exception as e:
exc = e
val = None
exc_type, exc_value, exc_traceback = sys.exc_info()
tb = traceback.TracebackException(exc_type, exc_value, exc_traceback)
tb_class = exc_type
r = Maybe(val, tb, tb_class, exc)
return r
def assert_has_traceback(code, expected_elements):
import traceback
stack = None
try:
code()
except Exception:
stack = traceback.TracebackException(*sys.exc_info()).stack
else:
assert False, "The code didn't raise an exception"
expected_elements = [('assert_has_traceback', 'code()')
] + expected_elements
actual_elements = []
for frame in stack:
actual_elements.append((frame.name, frame.line))
assert expected_elements == actual_elements, \
"Expected traceback elements:\n{}\nGot:\n{}".format('\n'.join(map(str, expected_elements)), '\n'.join(map(str, actual_elements)))
def prepare_exception(
self, exc_info: ExcInfo) -> Union[Dict[str, str], Dict[str, None]]:
if exc_info == (None, None, None):
return {
'type': None,
'value': None,
'traceback': None,
}
else:
type_, value, tb = exc_info
tb = traceback.TracebackException(type_, value, tb)
return {
'type': type_.__name__,
'value': str(value),
'traceback': ''.join(tb.format()),
}
def users_list():
"""List all available user accounts."""
try:
items = mydojo.db.SQLDB.session.query(mydojo.db.UserModel).all()
if items:
click.echo("List of existing user accounts:")
for item in items:
click.echo(" - {}: {} ({})".format(item.login,
item.fullname,
','.join(item.roles)))
else:
click.echo("There are currently no user accounts in the database.")
except Exception: # pylint: disable=locally-disabled,broad-except
mydojo.db.SQLDB.session.rollback()
click.echo(traceback.TracebackException(*sys.exc_info()))
def eval_expr(self, expr: types.CodeType, env: T.Dict[str,
T.Any]) -> T.Any:
"""This is a wrapper around expression.eval_expr().
It catches and logs any exception raised during evaluation. In
this case, the caught Exception object is returned."""
try:
return expression.eval_expr(expr, env)
except Exception as err: # pylint: disable=broad-except
self.log("Error while evaluating expression:", level="ERROR")
tb_exc = traceback.TracebackException(
*sys.exc_info()) # type: ignore
while tb_exc.stack and tb_exc.stack[0].filename != "expression":
del tb_exc.stack[0]
for line in tb_exc.format():
self.log(line.rstrip(os.linesep), level="ERROR")
return err
def rnaztobed(rnaz):
try:
tmpbed = []
for key in rnaz:
if key != 'header':
tmpbed.append('\t'.join(key.split('_')))
return '\n'.join(tmpbed)
except Exception as err:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type,
exc_value,
exc_tb,
)
print(''.join(tbe.format()), file=sys.stderr)
def write_header(out, fastadict=None):
try:
if fastadict:
head = str.join('\t', ['Chromosome', 'Seq', 'End', 'Count', 'ChromRelRefFreq', 'TotalRelRefFreq', 'tRNAs'])
else:
head = str.join('\t', ['Chromosome', 'Seq', 'End', 'Count', 'ChromRelRefFreq', 'TotalRelRefFreq'])
with gzip.open(out,'wb') as o:
o.write(bytes(head+'\n',encoding='UTF-8'))
except Exception as err:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type, exc_value, exc_tb,
)
with open('error','a') as h:
print(''.join(tbe.format()), file=h)
def runjob(jobtorun):
try:
logid = scriptname + '.runjob: '
#return subprocess.run(jobtorun, shell=True, universal_newlines=True, capture_output=True) # python >= 3.7
job = subprocess.Popen(jobtorun,
shell=True,
universal_newlines=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True)
while True:
status = job.poll()
output = str.join('', job.stdout.readlines()).rstrip()
err = str.join('', job.stderr.readlines()).rstrip()
if output:
log.info(logid + str(output))
if any(x in output
for x in ['ERROR', 'Error', 'error', 'Exception'
]) and not 'Workflow finished' in output:
log.error(logid + 'STOPOUT: ' + str(err))
job.kill()
sys.exit(output)
if err:
if not 'Workflow finished' in err and not 'Nothing to be done' in err and any(
x in err
for x in ['ERROR', 'Error', 'error', 'Exception']):
log.error(logid + 'STOPERROR: ' + str(err))
job.kill()
sys.exit(err)
else:
log.info(logid + str(err))
if status is not None:
break
return status
except Exception as err:
job.kill()
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type,
exc_value,
exc_tb,
)
log.error(''.join(tbe.format()))
def print_current_exception(sanitize: bool) -> None:
"""Print a traceback for the current exception to stdout.
If `sanitize` is true, the filename's full path is stripped,
and the line is set to 0. These changes make the test output
less brittle."""
if sanitize:
tb = traceback.TracebackException(*sys.exc_info())
if tb.exc_type == InstrProcessingFailure and tb.__cause__:
tb = tb.__cause__
for frame in tb.stack:
frame.lineno = 0
frame.filename = Path(frame.filename).name
for line in tb.format(chain=False):
print(line, end="")
else:
traceback.print_exc(file=sys.stdout)
def get_exception(exception, sb, level=0):
# if str(traceback.format_stack()) is not None:
# sb.append(os.linesep + spaces + exception.msg + str(traceback.format_stack()))
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = traceback.TracebackException(exc_type, exc_value, exc_tb)
formatted = ''.join(tbe.format())
trace = traceback.format_exc(2)
sb = os.linesep + exception.msg + os.linesep + traceback.format_exc()
if exception is Exception:
# if (ex is Exception and (ex as AggregateException).InnerExceptions.Count > 0):
for nested_exception in exception:
# for exception in (ex as AggregateException).InnerExceptions):
StringProcessor.get_exception(nested_exception, sb, level + 1)
elif len(exception.args) == 0:
StringProcessor.get_exception(exception.InnerException, sb, level + 2)
return sb
def rnaztobed(rnaz):
try:
tmpbed = []
for key in rnaz:
if key != "header":
tmpbed.append("\t".join(key.split("_")))
return "\n".join(tmpbed)
except Exception:
exc_type, exc_value, exc_tb = sys.exc_info()
tbe = tb.TracebackException(
exc_type,
exc_value,
exc_tb,
)
print("".join(tbe.format()), file=sys.stderr)
