def login(): if request.method == 'POST': username = request.form['username'] password = request.form['password'] if validate_login(username, password): session['username'] = username ## <DEBUGGING> response = fitocracy_request(username, password) msg = 'Sucessful login: '******'default.html', msg = msg) ## </DEBUGGING> return redirect(url_for('user', user_name = username)) else: msg = 'ERROR: Invalid username or password!' return render_template('default.html', msg = msg) return render_template('default.html')
def __str__(self): return """ Nodes: {} Edges: {} """.format(pprint.saferepr(self.data), pprint.saferepr(self.adj))
def content(self): vars = odict() request = tg.request._current_obj() response = tg.response._current_obj() attr_dict = request.environ['webob.adhoc_attrs'].copy() attr_dict['response'] = repr(response.__dict__) for entry in attr_dict.keys(): if entry.startswith('tgdb_'): del attr_dict[entry] vars['GET'] = [(k, request.GET.getall(k)) for k in request.GET] vars['POST'] = [(k, [saferepr(p) for p in request.POST.getall(k)]) for k in request.POST] vars['Cookies'] = [(k, request.cookies.get(k)) for k in request.cookies] vars['Headers'] = [(k, saferepr(v)) for k, v in request.environ.iteritems() if k.startswith('HTTP_') or k in request_header_filter] vars['Request Attributes'] = [(k, saferepr(v)) for k, v in attr_dict.iteritems() if not callable(v)] vars['Environ'] = [(k, saferepr(v)) for k, v in request.environ.iteritems()] return unicode(render( dict(vars=vars), 'genshi', 'tgext.debugbar.sections.templates.request' ).split('\n', 1)[-1])
def __str__(self): return pprint.saferepr( """ Nodes: {} Edges: {} """.format(pprint.saferepr(self.data), \ pprint.saferepr([str(x) for x in self.adj])))
def content(self): vars = odict() request = tg.request._current_obj() response = tg.response._current_obj() attr_dict = request.environ.get("webob.adhoc_attrs", {}).copy() attr_dict["response"] = repr(response.__dict__) for entry in list(attr_dict.keys()): if entry.startswith("tgdb_"): del attr_dict[entry] vars["GET"] = [(k, request.GET.getall(k)) for k in request.GET] vars["POST"] = [(k, [saferepr(p) for p in request.POST.getall(k)]) for k in request.POST] vars["Cookies"] = [(k, request.cookies.get(k)) for k in request.cookies] vars["Headers"] = [ (k, saferepr(v)) for k, v in request.environ.items() if k.startswith("HTTP_") or k in request_header_filter ] vars["Request Attributes"] = [(k, saferepr(v)) for k, v in attr_dict.items() if not callable(v)] vars["Environ"] = [(k, saferepr(v)) for k, v in request.environ.items()] return unicode_text( render( dict(vars=vars), tg.config["debugbar.engine"], "tgext.debugbar.sections.templates.request!html" ).split("\n", 1)[-1] )
def content(self): vars = odict() request = tg.request._current_obj() response = tg.response._current_obj() attr_dict = request.environ.get('webob.adhoc_attrs', {}).copy() attr_dict['response'] = repr(response.__dict__) for entry in list(attr_dict.keys()): if entry.startswith('tgdb_'): del attr_dict[entry] vars['GET'] = [(k, request.GET.getall(k)) for k in request.GET] vars['POST'] = [(k, [saferepr(p) for p in request.POST.getall(k)]) for k in request.POST] vars['Cookies'] = [(k, request.cookies.get(k)) for k in request.cookies] vars['Headers'] = [ (k, saferepr(v)) for k, v in request.environ.items() if k.startswith('HTTP_') or k in request_header_filter ] vars['Request Attributes'] = [(k, saferepr(v)) for k, v in attr_dict.items() if not callable(v)] vars['Environ'] = [(k, saferepr(v)) for k, v in request.environ.items()] return unicode_text( render(dict(vars=vars), tg.config['debugbar.engine'], 'tgext.debugbar.sections.templates.request!html').split( '\n', 1)[-1])
def assertNotIn(self, member, container, msg=None): """ Report an assertion failure if *member* IS in *container*. """ if member in container: fmsg = "%s unexpectedly found in %s" % (pp.saferepr(member), pp.saferepr(container)) self.fail(msg or fmsg)
def assertIn(self, member, container, msg=None): """ Report an assertion failure if *member* is not in *container*. """ if member not in container: fmsg = "%s not found in %s" % (pp.saferepr(member), pp.saferepr(container)) self.fail(msg or fmsg)
def __repr__(self): str = "client options:" str += pprint.saferepr(self.client_options) + '\n' for execution_params in self.execution_context.values(): for command, command_options in execution_params: str += f"command options for {command.app.name} : " str += pprint.saferepr(command_options) str += '\n' return str
def getattr(self, path, fh=None): self.log("getattr " + path) if path != "/" and len(folder_cache) == 1: self.log("getattr " + path + " first read of root") self.populateFolderCache("/") if path in folder_cache: if 'st_size' in folder_cache[path]: return_val = folder_cache[path] self.log("getattr " + path + " " + pprint.saferepr(return_val)) return return_val else: self.log("getattr boxid: " + str(folder_cache[path]["boxid"])) file_query = client.file(folder_cache[path]["boxid"]).get() folder_cache[path]["st_size"] = file_query["size"] folder_cache[path]["st_ctime"] = time.mktime( time.strptime(file_query["created_at"], "%Y-%m-%dT%H:%M:%S-07:00")) folder_cache[path]["st_mtime"] = time.mktime( time.strptime(file_query["modified_at"], "%Y-%m-%dT%H:%M:%S-07:00")) folder_cache[path]["st_atime"] = time.time() return_val = folder_cache[path] self.log("getattr " + path + " " + pprint.saferepr(return_val)) return return_val else: # Not in cache, try populateFolderCache one direcory up oneback = path.split("/") oneback.pop() oneback.reverse() oneback.pop() oneback.reverse() self.log("getattr " + path + " oneback: " + pprint.saferepr(oneback)) if len(oneback) > 0: searchpath = "" for element in oneback: searchpath += "/" + element self.log("getattr " + path + " searchpath: " + searchpath) self.populateFolderCache(searchpath) if path in folder_cache: return_val = folder_cache[path] self.log("getattr " + path + " " + pprint.saferepr(return_val)) return return_val else: self.log("getattr " + path + " ENOENT (Not Found) - folder not found") raise FuseOSError(errno.ENOENT) return {} else: self.log("getattr " + path + " ENOENT (Not Found) - oneback empty") raise FuseOSError(errno.ENOENT) return {}
def request_parameters(request): data = {} yield from request.post() data.update({ 'url': "http://{}{}".format(request.host, request.path), 'method': request.method, 'get': [(k, request.GET.getall(k)) for k in request.GET], 'post': [(k, saferepr(v)) for k, v in request.POST.items()], 'cookies': [(k, request.cookies.get(k)) for k in request.cookies], 'attrs': [(k, saferepr(v)) for k, v in request.items()], 'headers': {k.title(): str(v) for k, v in request.headers.items()}, }) return data
def run_zone_tests(self, tests): for test in tests: lambda_test = self.build_test( test[1] ) setattr(self.TestBindBuilds, "test_"+str(test[0]), lambda_test ) suite = unittest.TestLoader().loadTestsFromTestCase(self.TestBindBuilds) test_results = unittest.TextTestRunner(verbosity=2).run(suite) if test_results.errors or test_results.failures: # This could be more pretty email_to = self.testing_email result_email = "To: %s\n" % (email_to) result_email += "From: %s\n" % (self.local_email) result_email += "Subject: %s\n" % ("Bind build notifications") if test_results.errors: result_email += "Errors:\n"+pprint.saferepr(test_results.errors) if test_results.failures: result_email += "Failures:\n"+pprint.saferepr(test_results.failures) self.mail.sendmail(self.local_email, email_to, result_email)
def mainBody(self): if not self.anyReady(): self.pause() return 1 while self.dataReady("inbox"): self.send(saferepr(self.recv()) + "\n", "outbox") return 1
def _format_assertmsg(obj): """Format the custom assertion message given. For strings this simply replaces newlines with '\n~' so that util.format_explanation() will preserve them instead of escaping newlines. For other objects py.io.saferepr() is used first. """ # reprlib appears to have a bug which means that if a string # contains a newline it gets escaped, however if an object has a # .__repr__() which contains newlines it does not get escaped. # However in either case we want to preserve the newline. # if isinstance(obj, six.text_type) or isinstance(obj, six.binary_type): if isinstance(obj, basestring): s = obj is_repr = False else: s = pprint.saferepr(obj) is_repr = True if isinstance(s, unicode): t = unicode else: t = str s = s.replace(t("\n"), t("\n~")).replace(t("%"), t("%%")) if is_repr: s = s.replace(t("\\n"), t("\n~")) return s + "\n"
def mainBody(self): if not self.anyReady(): self.pause() return 1 while self.dataReady("inbox"): self.send( saferepr(self.recv())+"\n", "outbox") return 1
def load_content(loader, ctx: common.Context) -> common.Result: """ Load & filter content """ start = time.time() # load list of parts result = loader.load() if ctx.debug: ctx.log_debug("loaded: %s", result) result.debug['loaded_duration'] = time.time() - start fltr_start = time.time() result.debug['items_loaded'] = len(result.items) result.debug['filters_status'] = {} # apply filters for fltcfg in ctx.input_conf.get('filters') or []: flt = filters.get_filter(fltcfg, ctx) if not flt: ctx.log_error("missing filter: %s", fltcfg) continue result = flt.filter(result) if ctx.debug: ctx.log_debug("filtered by %s: %s", flt, pprint.saferepr(result)) result.debug['filters_status'][flt.name] = len(result.items) if ctx.args.debug: result.meta['filter_duration'] = time.time() - fltr_start result.debug['items_filterd'] = len(result.items) result.meta['update_duration'] = time.time() - start result.meta['update_date'] = time.time() if not result.title: result.title = ctx.name if ctx.debug: ctx.log_debug("result: %s", result) return result
def content(self): vars = {} request = self.request attr_dict = request.__dict__.copy() # environ is displayed separately del attr_dict['environ'] if 'response' in attr_dict: attr_dict['response'] = repr(attr_dict['response']) vars.update({ 'get': [(k, request.GET.getall(k)) for k in request.GET], 'post': [(k, [saferepr(p) for p in request.POST.getall(k)]) for k in request.POST], 'cookies': [(k, request.cookies.get(k)) for k in request.cookies], 'attrs': dictrepr(attr_dict), 'environ': dictrepr(request.environ), }) if hasattr(self.request, 'session'): vars.update({ 'session': dictrepr(self.request.session), }) return self.render( 'pyramid_debugtoolbar.panels:templates/request_vars.dbtmako', vars, request=self.request)
def printReport(timecounter, text): text += ["LVL UP"] text += [pprint.saferepr(counters.echo())] strtime = "{:0>8}".format( datetime.timedelta(seconds=round(time.clock() - timecounter, 1))) print(strtime + " " + ", ".join(text)) resetValues()
def duplicate_key(query): raw_params = (() if query["raw_params"] is None else tuple( query["raw_params"])) # saferepr() avoids problems because of unhashable types # (e.g. lists) when used as dictionary keys. # https://github.com/jazzband/django-debug-toolbar/issues/1091 return (query["raw_sql"], saferepr(raw_params))
def destroy(self): if self._write_to_log_on_exit: logger.debug('Metrics at time of destruction:') for k, v in FlatMetricsNamespaceDataView( self._namespace).get_data().items(): logger.debug('{key}={value}'.format(key=k, value=saferepr(v))) logger.debug('Metrics Done')
def get_token(self, username, password, one_time_password=None): auth_data = { "scopes": ["gist"], "note": "Sublime GitHub", "note_url": "https://github.com/bgreenlee/sublime-github", } headers = {"X-GitHub-OTP": one_time_password} if one_time_password else {} resp = self.rsession.post( self.base_uri + "/authorizations", headers=headers, auth=(username, password), proxies=self.proxies, data=json.dumps(auth_data), ) if resp.status_code == requests.codes.CREATED: logger.debug(pprint.saferepr(resp)) data = json.loads(resp.text) return data["token"] elif resp.status_code == requests.codes.UNAUTHORIZED: if resp.headers["X-GitHub-OTP"].startswith("required"): raise self.OTPNeededException() else: raise self.UnauthorizedException() else: raise self.UnknownException("%d %s" % (resp.status_code, resp.text))
def get_token(self, username, password, one_time_password=None): auth_data = { "scopes": ["gist"], "note": "Sublime GitHub", "note_url": "https://github.com/bgreenlee/sublime-github" } headers = { 'X-GitHub-OTP': one_time_password } if one_time_password else {} resp = self.rsession.post(self.base_uri + "/authorizations", headers=headers, auth=(username, password), proxies=self.proxies, data=json.dumps(auth_data)) if resp.status_code == requests.codes.CREATED: logger.debug(pprint.saferepr(resp)) data = json.loads(resp.text) return data["token"] elif resp.status_code == requests.codes.UNAUTHORIZED: if resp.headers['X-GitHub-OTP'].startswith('required'): raise self.OTPNeededException() else: raise self.UnauthorizedException() else: raise self.UnknownException("%d %s" % (resp.status_code, resp.text))
def test_same_as_repr(self): # Simple objects, small containers and classes that overwrite __repr__ # For those the result should be the same as repr(). # Ahem. The docs don't say anything about that -- this appears to # be testing an implementation quirk. Starting in Python 2.5, it's # not true for dicts: pprint always sorts dicts by key now; before, # it sorted a dict display if and only if the display required # multiple lines. For that reason, dicts with more than one element # aren't tested here. for simple in (0, 0, 0+0j, 0.0, "", b"", bytearray(), (), tuple2(), tuple3(), [], list2(), list3(), set(), set2(), set3(), frozenset(), frozenset2(), frozenset3(), {}, dict2(), dict3(), self.assertTrue, pprint, -6, -6, -6-6j, -1.5, "x", b"x", bytearray(b"x"), (3,), [3], {3: 6}, (1,2), [3,4], {5: 6}, tuple2((1,2)), tuple3((1,2)), tuple3(range(100)), [3,4], list2([3,4]), list3([3,4]), list3(range(100)), set({7}), set2({7}), set3({7}), frozenset({8}), frozenset2({8}), frozenset3({8}), dict2({5: 6}), dict3({5: 6}), range(10, -11, -1), True, False, None, ..., ): native = repr(simple) self.assertEqual(pprint.pformat(simple), native) self.assertEqual(pprint.pformat(simple, width=1, indent=0) .replace('\n', ' '), native) self.assertEqual(pprint.saferepr(simple), native)
def __init__(self, request): self.request = request self.data = data = {} attrs = request.__dict__.copy() # environ is displayed separately del attrs['environ'] if 'response' in attrs: attrs['response'] = repr(attrs['response']) if 'session' in attrs: self.process_session_attr(self, attrs['session']) del attrs['session'] else: # only process the session if it's accessed callback_on_load(request, 'session', self.process_session_attr) data.update({ 'get': [(k, request.GET.getall(k)) for k in request.GET], 'post': [(k, saferepr(v)) for k, v in request.POST.items()], 'cookies': [(k, request.cookies.get(k)) for k in request.cookies], 'environ': dictrepr(request.environ), 'extracted_attributes': {}, 'attrs': dictrepr(attrs), 'session': None, })
def json_dumps_default(v): if isinstance(v, datetime.datetime): return to_iso_datetime(v) elif isinstance(v, float) and (math.isnan(v) or math.isinf(v)): return None else: return pprint.saferepr(v)
def content(self): vars = {} request = self.request attr_dict = request.__dict__.copy() # environ is displayed separately del attr_dict['environ'] if 'response' in attr_dict: attr_dict['response'] = repr(attr_dict['response']) vars.update({ 'get': [(k, request.GET.getall(k)) for k in request.GET], 'post': [(k, [saferepr(p) for p in request.POST.getall(k)]) for k in request.POST], 'cookies': [(k, request.cookies.get(k)) for k in request.cookies], 'attrs': dictrepr(attr_dict), 'environ': dictrepr(request.environ), }) if hasattr(self.request, 'session'): vars.update({ 'session': dictrepr(self.request.session), }) return self.render( 'pyramid_debugtoolbar.panels:templates/request_vars.mako', vars, request=self.request)
def test_same_as_repr(self): # Simple objects, small containers and classes that overwrite __repr__ # For those the result should be the same as repr(). # Ahem. The docs don't say anything about that -- this appears to # be testing an implementation quirk. Starting in Python 2.5, it's # not true for dicts: pprint always sorts dicts by key now; before, # it sorted a dict display if and only if the display required # multiple lines. For that reason, dicts with more than one element # aren't tested here. for simple in (0, 0, 0 + 0j, 0.0, "", b"", (), tuple2(), tuple3(), [], list2(), list3(), set(), set2(), set3(), frozenset(), frozenset2(), frozenset3(), {}, dict2(), dict3(), self.assertTrue, pprint, -6, -6, -6 - 6j, -1.5, "x", b"x", (3, ), [3], { 3: 6 }, (1, 2), [3, 4], { 5: 6 }, tuple2((1, 2)), tuple3( (1, 2)), tuple3(list(range(100))), [3, 4], list2([3, 4]), list3([3, 4]), list3(list(range(100))), set({7}), set2({7}), set3({7}), frozenset({8}), frozenset2({8}), frozenset3({8}), dict2({5: 6}), dict3({5: 6}), list(range(10, -11, -1))): native = repr(simple) self.assertEqual(pprint.pformat(simple), native) self.assertEqual( pprint.pformat(simple, width=1, indent=0).replace('\n', ' '), native) self.assertEqual(pprint.saferepr(simple), native)
def test_container_repr_override_called(self): N = 1000 # Ensure that __repr__ override is called for subclasses of containers for cont in ( list_custom_repr(), list_custom_repr([1, 2, 3]), list_custom_repr(range(N)), tuple_custom_repr(), tuple_custom_repr([1, 2, 3]), tuple_custom_repr(range(N)), set_custom_repr(), set_custom_repr([1, 2, 3]), set_custom_repr(range(N)), frozenset_custom_repr(), frozenset_custom_repr([1, 2, 3]), frozenset_custom_repr(range(N)), dict_custom_repr(), dict_custom_repr({5: 6}), dict_custom_repr(zip(range(N), range(N))), ): native = repr(cont) expected = '*' * len(native) self.assertEqual(pprint.pformat(cont), expected) self.assertEqual(pprint.pformat(cont, width=1, indent=0), expected) self.assertEqual(pprint.saferepr(cont), expected)
def wakeup_asg(asg): log.debug('Initializing ASG: %s', pprint.saferepr(asg)) tags = {i['Key']: i['Value'] for i in asg['Tags']} if not valid(tags, desired_wakeup_tags_schema): error = "Autoscaling group doesn't contain correct wakeup tags %s ".format( c.jsonify(tags)) log.error(error) raise ValueError(error) initial_capacity = int(tags['InitialCapacity']) desired_capacity = int(tags['DesiredCapacity']) min_size = int(tags['MinSize']) max_size = int(tags['MaxSize']) if (int(asg['MinSize']) != min_size or \ int(asg['MaxSize']) != max_size or \ int(asg['DesiredCapacity']) != desired_capacity) and \ int(asg['MaxSize']) == initial_capacity: log.info( 'Resizing autoscaling group from initial %i to desired %i capacity', initial_capacity, desired_capacity) asg_client.update_auto_scaling_group( AutoScalingGroupName=asg['AutoScalingGroupName'], MinSize=min_size, MaxSize=max_size, DesiredCapacity=desired_capacity)
def duplicate_key(query): raw_params = ( () if query["raw_params"] is None else tuple(query["raw_params"]) ) # saferepr() avoids problems because of unhashable types # (e.g. lists) when used as dictionary keys. # https://github.com/jazzband/django-debug-toolbar/issues/1091 return (query["raw_sql"], saferepr(raw_params))
def _json_serializer(obj): """JSON serializer for objects not serializable by default json code""" if isinstance(obj, (datetime, date)): return obj.isoformat(sep=" ") if isinstance(obj, (types.TracebackType, TracebackFrameProxy)): return "<Traceback object>" return saferepr(obj)
def _err_msg(self, sql, args=None): msg = "Exception for table %s.%s\n" % (self.db, self.name) msg += 'SQL request %s\n' % sql if args: import pprint msg += 'Arguments : %s\n' % pprint.saferepr(args) out = io.StringIO() traceback.print_exc(file=out) msg += out.getvalue() return msg
def save_error(self): ctx = self.ctx exc = self.exc timestamp = str(datetime.utcnow()).split('.')[0].replace(' ', '_').replace(':', '') filename = str(ctx.message.id) + '_' + timestamp + '.error' try: raise exc except: tb = traceback.format_exc() content = ( '{0.stamp}\n\nMESSAGE CONTENT:\n{0.message.content}\n\n' 'COMMAND: {0.command.qualified_name}\nARGS: {1}\nKWARGS: {2}\n\n{3}' ).format(ctx, saferepr(ctx.args[2:]), saferepr(ctx.kwargs), tb) with open('error/{0}'.format(filename), 'w', encoding='utf-8-sig') as f: f.write(content)
def _base__repr__(self): import pprint obj = vars(self) output = {} for i in self.__mapper__.columns.keys(): try: output[i] = obj[i] except KeyError: pass return pprint.saferepr((output, self.__mapper__.relationships.keys()))
def process_response(self, response): self.data = data = {} request = self.request yield from request.post() data.update({ 'get': [(k, request.GET.getall(k)) for k in request.GET], 'post': [(k, saferepr(v)) for k, v in request.POST.items()], 'cookies': [(k, request.cookies.get(k)) for k in request.cookies], 'attrs': [(k, v) for k, v in request.items()], })
def main(): try: return wifimitmcli() except KeyboardInterrupt: print('Stopping.') return ExitCode.KEYBOARD_INTERRUPT.value except subprocess.CalledProcessError as e: logger.error(str(e) + ' ' + saferepr(e)) print(str(e), file=sys.stderr) return ExitCode.SUBPROCESS_ERROR.value
async def handle_DATA(self, server, session, envelope): post = {} msg = email.message_from_bytes(envelope.content) print(saferepr(msg)) if 'message-id' in msg: print('Message-ID:', msg['message-id']) post['headers'] = dict(msg.items()) for part in msg.walk(): if part.get_content_type() == 'text/plain' and not bool( post.get('plain')): post['plain'] = part.get_payload() if part.get_content_type() == 'text/html' and not bool( post.get('html')): post['html'] = part.get_payload() if not part.get_content_disposition() is None: with open('/tmp/file.jpg', 'wb') as f: f.write(part.get_payload(i=None, decode=True)) print(saferepr(post)) return '250 Message accepted for delivery'
def send_task(self, task_id): """The task of sending a task to Asana.""" task = Task.objects.get(id=task_id) try: if not settings.TESTING: AsanaApi().send_task(task) except Exception as e: error_message = ('Can`t send the task to Asana: %s', pprint.saferepr(e)) logger.exception(error_message) raise self.retry(exc=e, countdown=2**(self.request.retries + 5))
def run_zone_tests(self, tests): for test in tests: lambda_test = self.build_test(test[1]) setattr(self.TestBindBuilds, "test_" + str(test[0]), lambda_test) suite = unittest.TestLoader().loadTestsFromTestCase( self.TestBindBuilds) test_results = unittest.TextTestRunner(verbosity=2).run(suite) if test_results.errors or test_results.failures: # This could be more pretty email_to = self.testing_email result_email = "To: %s\n" % (email_to) result_email += "From: %s\n" % (self.local_email) result_email += "Subject: %s\n" % ("Bind build notifications") if test_results.errors: result_email += "Errors:\n" + pprint.saferepr( test_results.errors) if test_results.failures: result_email += "Failures:\n" + pprint.saferepr( test_results.failures) self.mail.sendmail(self.local_email, email_to, result_email)
def def2model(de): sections = { section: parse_section(de[section]) for section in ['log', 'event'] } processors = { name: parse_section(processor) for name, processor in de['job'].items() } mode = FileMode( target_versions={TargetVersion.PY36}, string_normalization=False, ) sections_f = black.format_str(saferepr(sections), mode=mode) processors_f = black.format_str(saferepr(processors), mode=mode) print( def2model_template.format(sections=sections_f, processors=processors_f))
def _repr_(self): """ EXAMPLES:: sage: from sage.sets.family import FiniteFamily sage: FiniteFamily({3: 'a'}) # indirect doctest Finite family {3: 'a'} sage: FiniteFamily({3: 'a', 4: 'b'}) # indirect doctest Finite family {3: 'a', 4: 'b'} sage: FiniteFamily({3: 'a', 4: 'b'}, keys=[4,3]) # indirect doctest Finite family {4: 'b', 3: 'a'} """ if self._keys is None: d = ' '.join(pformat(self._dictionary)[1:-1].splitlines()) else: d = ', '.join( '{}: {}'.format(saferepr(key), saferepr(self._dictionary[key])) for key in self._keys) return 'Finite family {{{}}}'.format(d)
def endFile(self): # Print out all the dictionaries as Python strings. # Could just print(dict) but that's not human-readable dicts = ([self.basetypes, 'basetypes'], [self.consts, 'consts'], [self.enums, 'enums'], [self.flags, 'flags'], [self.funcpointers, 'funcpointers'], [self.protos, 'protos'], [self.structs, 'structs'], [self.handles, 'handles'], [self.defines, 'defines'], [self.typeCategory, 'typeCategory'], [self.alias, 'alias']) for (entry_dict, name) in dicts: write(name + ' = {}', file=self.outFile) for key in sorted(entry_dict.keys()): write(name + '[' + enquote(key) + '] = ', entry_dict[key], file=self.outFile) # Dictionary containing the relationships of a type # (e.g. a dictionary with each related type as keys). write('mapDict = {}', file=self.outFile) # Could just print(self.mapDict), but prefer something # human-readable and stable-ordered for baseType in sorted(self.mapDict.keys()): write('mapDict[' + enquote(baseType) + '] = ', file=self.outFile, end='') pprint.pprint(self.mapDict[baseType], self.outFile) # Generate feature <-> interface mappings for feature in self.features: self.mapInterfaces(feature) # Write out the reverse map from APIs to requiring features write('requiredBy = {}', file=self.outFile) for api in sorted(self.apimap): # Construct list of requirements as Python list arguments ##reqs = ', '.join('({}, {})'.format(enquote(dep[0]), enquote(dep[1])) for dep in self.apimap[api]) ##write('requiredBy[{}] = ( {} )'.format(enquote(api), reqs), file=self.outFile) # Ideally these would be sorted by dep[0] as well reqs = ', '.join( '({}, {})'.format(enquote(dep[0]), enquote(dep[1])) for dep in self.apimap[api]) write('requiredBy[{}] = {}'.format( enquote(api), pprint.saferepr(self.apimap[api])), file=self.outFile) OutputGenerator.endFile(self)
def _pprint_numdict( self, object, stream, indent, allowance, context, level ): write = stream.write name = type(object).__name__ indent += len(name) + 1 end = [" " * indent, 'default=', _pprint.saferepr(object.default),')'] stream.write(name + '(') self._pprint_dict(object, stream, indent, allowance, context, level) stream.write(',\n') stream.write("".join(end))
def __str__(self): string = BaseTestCase.__str__(self); data = self.__data; if data: # cuts long data representation dataRepr = pprint.saferepr(data); if 80 < len(dataRepr) : dataRepr = '{0}...{1}'.format(dataRepr[:70], dataRepr[-7:]); string += ' with data set #{0:d} {1}'.format( self.__dataId, dataRepr, ); return string;
def __init__(self, request): self.data = data = {} attr_dict = request.__dict__.copy() # environ is displayed separately del attr_dict['environ'] if 'response' in attr_dict: attr_dict['response'] = repr(attr_dict['response']) data.update({ 'get': [(k, request.GET.getall(k)) for k in request.GET], 'post': [(k, saferepr(v)) for k, v in request.POST.items()], 'cookies': [(k, request.cookies.get(k)) for k in request.cookies], 'attrs': dictrepr(attr_dict), 'environ': dictrepr(request.environ), }) if hasattr(request, 'session'): data.update({ 'session': dictrepr(request.session), })
def __init__(self, request): self.data = data = {} attr_dict = request.__dict__.copy() # environ is displayed separately del attr_dict["environ"] if "response" in attr_dict: attr_dict["response"] = repr(attr_dict["response"]) data.update( { "get": [(k, request.GET.getall(k)) for k in request.GET], "post": [(k, saferepr(v)) for k, v in request.POST.items()], "cookies": [(k, request.cookies.get(k)) for k in request.cookies], "attrs": dictrepr(attr_dict), "environ": dictrepr(request.environ), } ) if hasattr(request, "session"): data.update({"session": dictrepr(request.session)})
def get_token(self, username, password): auth_data = { "scopes": ["gist"], "note": "Sublime GitHub", "note_url": "https://github.com/bgreenlee/sublime-github" } resp = self.rsession.post(self.base_uri + "/authorizations", auth=(username, password), proxies=self.proxies, data=json.dumps(auth_data)) if resp.status_code == requests.codes.CREATED: logger.debug(pprint.saferepr(resp)) data = json.loads(resp.text) return data["token"] elif resp.status_code == requests.codes.UNAUTHORIZED: raise self.UnauthorizedException() else: raise self.UnknownException("%d %s" % (resp.status_code, resp.text))
def amon_tween(request, amonpy=amonpy): try: return handler(request) except Exception as exc: url = request.url env_excludes = ("HTTP_COOKIE", "webob._parsed_cookies") env = [(k, request.get(k)) for k in request.environ if k not in env_excludes] info = exc_info(exc, sys.exc_info()[2]) extras = {} if request.GET: extras.update({"get": saferepr([(k, request.GET.getall(k)) for k in request.GET])}) if request.POST: extras.update( {"post": saferepr([(k, [saferepr(p) for p in request.POST.getall(k)]) for k in request.POST])} ) if request.cookies: extras.update({"cookies": saferepr(request.cookies.items())}) if hasattr(request, "session"): if request.session: extras.update({"session": saferepr(request.session.items())}) if request.matchdict: extras.update({"matchdict": saferepr(request.matchdict.items())}) if request.matched_route: extras.update( { "matched_route": saferepr( [("name", request.matched_route.name), ("path", request.matched_route.path)] ) } ) data = { "exception_class": info["exception_class"], "url": url, "backtrace": info["backtrace"], "message": info["message"], "enviroment": saferepr(env), "data": extras, } amonpy.exception(data) raise
def process_response(self, response): self.data = data = {} request = self.request post_data = yield from request.post() data.update({ 'get': [(k, request.query.getall(k)) for k in sorted(request.query)], 'post': [(k, saferepr(post_data.getall(k))) for k in sorted(post_data)], 'cookies': [(k, v) for k, v in sorted(request.cookies.items())], 'attrs': [(k, v) for k, v in sorted(request.items())], }) # TODO: think about aiohttp_security # session to separate table session = request.get('aiohttp_session') if session and not session.empty: data.update({ 'session': [(k, v) for k, v in sorted(session.items())], })
def parseArguments(): """Parse the command-line arguments.""" parser = argparse.ArgumentParser(description=__doc__.split("\n")[0]) input = parser.add_argument_group("input", description="Supported URL list formats.") input.add_argument("-g", "--gcsv", nargs="?", help="path to Google crawl error csv file(s)") input.add_argument("-p", "--plain", nargs="?", help="path to newline separated file(s)") output = parser.add_argument_group("output", description="Supported output formats.") formats = {"rack": "rack-rewrite 301 static redirect", "csv": "comma separated"} output.add_argument("-o", "--output", choices=formats.keys(), help="an output format; one of: " + pprint.saferepr(formats) + " else, a machine-readable format") output.add_argument("-e", "--ext", action="store_true", help="remove file extension in redirects") output.add_argument("-s", "--subdomain", action="store_true", help="remove subdomains in redirects") files = parser.add_argument_group("files", description="Heuristics regarding filename format.") files.add_argument("-u", "--utc", action="store_true", help="filenames start with a date in UTC format") search = parser.add_argument_group("search", description="Fuzzy search parameters.") search.add_argument("-c", "--cutoff", default=0.32, type=float, help="fuzzy search threshold (float, defaults to: 0.32)") search.add_argument("-m", "--matches", default=1, type=int, help="number of fuzzy search matches (int, defaults to: 1)") parser.add_argument("-d", "--dirs", nargs="?", default=".", help="path to directory(s) of files") return parser.parse_args()
def around(func, args, kwargs, func_name, compact): if conf['active']: if(not state['started']): raise RuntimeError('Not started.') state['tracing'] = func_name sys.settrace(trace_snapshot_at_return) try: ret_vals = func(*args, **kwargs) finally: sys.settrace(None) state['tracing'] = None if not compact and (state['last_was'] == 'post'): if conf['timestamps']: state['log'].write(" " * state['timestamp_size']) state['log'].write(conf['col_background'] + ("|" + " " * conf['indent_inc']) * state['indent'] + "|\n") if conf['timestamps']: state['log'].write(conf['col_background'] + timestamp()) state['log'].write( conf['col_background'] + ("|" + " " * conf['indent_inc']) * state['indent'] + "|-->{}{}{}(".format(conf['col_pre_func'], func_name, conf['col_background']) ) if state['traced_locals']: state['log'].write( "{}, ".format(conf['col_background']).join( "{}{} {}= {}{}".format(conf['col_argname'], key, conf['col_background'], conf['col_value'], pprint.saferepr(state['traced_locals'][key]) ) for key in state['traced_locals'] ) ) state['traced_locals'] = None state['log'].write("{})\n".format(conf['col_background'])) state['log'].write(conf['col_reset']) state['last_was'] = 'around' return(ret_vals)
def __repr__(self): return "%s(%s)" % (self.__class__, pprint.saferepr(self.__dict__))
def value_repr(self, instance): return '<pre style="display:inline-block;white-space:pre-wrap;">{}</pre>'.format( escape(saferepr(instance.value)) )
def log(self, fault, runtime, *args): """ Log the transaction """ # Do not log system or Get calls #if self.name.startswith('system') or self.name.startswith('Get'): # return False # Do not log ReportRunlevel if self.name.startswith('system'): return False if self.name.startswith('ReportRunlevel'): return False # Create a new event event = Event(self.api) event['fault_code'] = 0 if fault: event['fault_code'] = fault.faultCode event['runtime'] = runtime # Redact passwords and sessions newargs = args if args: newargs = [] for arg in args: if not isinstance(arg, dict): newargs.append(arg) continue # what type of auth this is if arg.has_key('AuthMethod'): auth_methods = ['session', 'password', 'capability', 'gpg', 'hmac','anonymous'] auth_method = arg['AuthMethod'] if auth_method in auth_methods: event['auth_type'] = auth_method for password in 'AuthString', 'session', 'password': if arg.has_key(password): arg = arg.copy() arg[password] = "Removed by API" newargs.append(arg) # Log call representation # XXX Truncate to avoid DoS event['call'] = self.name + pprint.saferepr(newargs) event['call_name'] = self.name # Both users and nodes can call some methods if isinstance(self.caller, Person): event['person_id'] = self.caller['person_id'] elif isinstance(self.caller, Node): event['node_id'] = self.caller['node_id'] event.sync(commit = False) if hasattr(self, 'event_objects') and isinstance(self.event_objects, dict): for key in self.event_objects.keys(): for object_id in self.event_objects[key]: event.add_object(key, object_id, commit = False) # Set the message for this event if fault: event['message'] = fault.faultString elif hasattr(self, 'message'): event['message'] = self.message # Commit event.sync()
def __str__(self): import pprint return pprint.saferepr(self)
def save_repr(d, filename, env_string=''): with open(filename, 'wb') as save_file: save_file.write(env_string) save_file.write('e=' + pprint.saferepr(d))
def __str__(self): return 'PageResult (%s): %s' % (self._status, pprint.saferepr(self.__dict__))