| # |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| # |
| |
| import re |
| from sys import stdout |
| |
| |
| class ThriftPrettyPrinter(object): |
| """Implements a pretty printer for Thrift objects. |
| Generates string representations. Does not output |
| to stdout, stderr, or any other file handles.""" |
| |
| # Inputs: |
| # redacted_fields - list of names of object attributes whose |
| # values will not be printed out |
| # indent - string containing only spaces, used as the |
| # base indentation where all other indentations |
| # will be multiples of this string |
| # objects_to_skip - list of names of objects attributes that |
| # will not be printed out, useful to ignore |
| # duplicate information such as query results |
| def __init__(self, |
| redacted_fields=("secret", "password"), |
| indent=" ", |
| objects_to_skip=("TRowSet", "TGetRuntimeProfileResp")): |
| if redacted_fields is not None: |
| assert type(redacted_fields) is list or \ |
| type(redacted_fields) is tuple, \ |
| "redacted_fields must be either a list or a tuple" |
| self.base_indent = indent |
| self.redacted_fields = redacted_fields |
| self.objects_to_skip = objects_to_skip |
| |
| self._objname_re = re.compile("^.*?'(.*?)'.*?$") |
| |
| def print_obj(self, thrift_obj, file_handle=stdout): |
| """Prints the provided 'thrift_obj' to the provided |
| file handle. If no file handle is specified, then |
| stdout will be used. The 'file_handle' object must |
| have a write(string) method. |
| |
| While this class is specifically targeted to printing |
| Thrift objects, there is no technical limitation preventing |
| any other type of object from being printed. However, the |
| output of non-Thrift objects may not be as nicely formatted.""" |
| |
| # Inputs: |
| # thrift_obj - the object to print out, its attributes will |
| # be walked recursively through the entire |
| # object structure and printed out |
| # file_handle - where the object will be written, defaults to stdout |
| # but can be any object with a write(str) method |
| self._internal_print(thrift_obj, self.base_indent, file_handle) |
| |
| def _internal_print(self, thrift_obj, indent, file_handle): |
| """Recursive function that does the work of walking and printing |
| an object.""" |
| # parse out the type name of the thrift object |
| obj_name = self._objname_re.match(str(type(thrift_obj))) \ |
| .group(1).split(".")[-1] |
| file_handle.write("<{0}>".format(obj_name)) |
| |
| if self.objects_to_skip.count(obj_name): |
| file_handle.write(" - <skipping>\n") |
| return |
| |
| indent = "{0}{1}".format(indent, self.base_indent) |
| file_handle.write("\n") |
| |
| if obj_name == "list" or obj_name == "tuple": |
| # lists and tuples have to be handled differently |
| # because the vars function does not operate on them |
| for attr_val in thrift_obj: |
| file_handle.write(indent) |
| self._internal_print(attr_val, indent, file_handle) |
| else: |
| # print out simple types first before printing out objects |
| # this ensures the simple types are easier to see |
| child_simple_attrs = {} |
| child_objs = {} |
| for attr_name in vars(thrift_obj): |
| attr_val = getattr(thrift_obj, attr_name) |
| if (hasattr(attr_val, '__dict__') |
| or attr_val is list |
| or attr_val is tuple): |
| child_objs[attr_name] = attr_val |
| else: |
| child_simple_attrs[attr_name] = attr_val |
| |
| # print out child attributes in alphabetical order |
| for child_attr_name in sorted(child_simple_attrs): |
| self._print_attr(child_attr_name, |
| child_simple_attrs[child_attr_name], |
| indent, |
| file_handle) |
| |
| # print out complex types objects, lists, or tuples |
| # in alphabetical order |
| for attr_name in sorted(child_objs): |
| self._print_attr(attr_name, |
| child_objs[attr_name], |
| indent, |
| file_handle) |
| |
| def _print_attr(self, attr_name, attr_val, indent, file_handle): |
| """Handles a single object attribute by either printing out |
| its name/value (for simple types) or recursing down into the |
| object (for objects/lists/tuples).""" |
| file_handle.write(indent) |
| |
| if attr_val is not None and self.redacted_fields.count(attr_name) > 0: |
| file_handle.write("- {0}: *******\n".format(attr_name)) |
| elif attr_val is None: |
| file_handle.write("- {0}: <None>\n".format(attr_name)) |
| elif type(attr_val) is list or type(attr_val) is tuple: |
| file_handle.write("[") |
| self._internal_print(attr_val, indent, file_handle) |
| file_handle.write("{0}]\n".format(indent)) |
| elif hasattr(attr_val, '__dict__'): |
| indent += "{0:{1}} {2}".format("", len(attr_name), self.base_indent) |
| file_handle.write("- {0}: ".format(attr_name)) |
| self._internal_print(attr_val, indent, file_handle) |
| else: |
| file_handle.write("- {0}: ".format(attr_name)) |
| try: |
| str(attr_val).decode("ascii") |
| file_handle.write("{0}".format(attr_val)) |
| except UnicodeDecodeError: |
| # python2 - string contains binary data |
| file_handle.write("<binary data>") |
| except AttributeError: |
| # python3 - does not require decoding strings and thus falls into this code |
| if isinstance(attr_val, bytes): |
| file_handle.write("<binary data>") |
| else: |
| file_handle.write("{0}".format(attr_val)) |
| file_handle.write("\n") |
