Prints relevant attributes of an object
		Args:
			displayAll		if True displays ALL class attributes.
176658
def show(self, displayAll = False):
		'''
		'''
		from pprint import pprint
		if displayAll:
			pprint(self.attributes)
		else:
			disp_attr = {}
			for key in self.disp_attr_keys:
				try:
					disp_attr[key] = self.attributes[key]
				except KeyError:
					if key == 'lowercaseEmail':
						disp_attr[key] = disp_attr['email'].lower()
					else:
						disp_attr[key] = None
			pprint(disp_attr)
		del pprint
606343
def visit_ClassDef(self, node):
        """"""
        # [[[cog
        # cog.out("print(pcolor('Enter class visitor', 'magenta'))")
        # ]]]
        # [[[end]]]
        # Get class information (name, line number, etc.)
        element_full_name = self._pop_indent_stack(node, "class")
        code_id = (self._fname, node.lineno)
        self._processed_line = node.lineno
        # Add class entry to dictionaries
        self._class_names.append(element_full_name)
        self._callables_db[element_full_name] = {
            "name": element_full_name,
            "type": "class",
            "code_id": code_id,
            "last_lineno": None,
        }
        self._reverse_callables_db[code_id] = element_full_name
        # [[[cog
        # code = """
        # print(
        #     pcolor(
        #         'Visiting class {0} @ {1}, indent = {2}'.format(
        #             element_full_name, code_id[1], self._get_indent(node)
        #         ),
        #         'green'
        #     )
        # )
        # """
        # cog.out(code)
        # ]]]
        # [[[end]]]
        self.generic_visit(node)
1207651
def get_all_fields(obj):
    """"""
    fields = []
    for f in obj._meta.fields:
        fname = f.name

        get_choice = "get_" + fname + "_display"
        if hasattr(obj, get_choice):
            value = getattr(obj, get_choice)()
        else:
            try:
                value = getattr(obj, fname)
            except Exception:
                value = None

        if isinstance(value, list):
            value = ",".join(str(v) for v in value)

        if f.editable and value and f.name:
            fields.append(
                {"label": f.verbose_name, "name": f.name, "value": value}
            )

    return fields
1032881
def render(self):
		
		self.widget.attrs = {
			k: v for k, v in self.attrs.items() if k[0] != "_"
		}
		self.set_input()

		if not self.attrs.get("_no_wrapper"):
			self.set_label()
			self.set_help()
			self.set_errors()
			self.set_classes()
			self.set_icon()  # Must be the bottom-most setter

		self.values["class"] = pad(" ".join(self.values["class"])).lstrip()
		result = mark_safe(FIELD_WRAPPER % self.values)
		self.widget.attrs = self.attrs  # Re-assign variables
		return result
1220423
def inspect
      attributes = {
        input: input,
        output: output,
        prefix: prefix,
        active_color: active_color,
        error_color: error_color,
        enabled_color: enabled_color,
        help_color: help_color
      }
      "#<#{self.class}: #{attributes.each { |name, val| "@#{name}=#{val}" }}"
    end
802388
def show(self, resolve_mac=True, print_result=True):
        """"""
        res = []
        for iface_name in sorted(self.data):
            dev = self.data[iface_name]
            mac = dev.mac
            if resolve_mac and conf.manufdb:
                mac = conf.manufdb._resolve_MAC(mac)
            validity_color = lambda x: conf.color_theme.red if x else \
                conf.color_theme.green
            description = validity_color(dev.is_invalid())(
                str(dev.description)
            )
            index = str(dev.win_index)
            res.append((index, description, str(dev.ip), mac))

        res = pretty_list(res, [("INDEX", "IFACE", "IP", "MAC")], sortBy=2)
        if print_result:
            print(res)
        else:
            return res
192836
def attributes(cls):
        

        for k in dir(cls):
            v = getattr(cls, k)
            if isinstance(v, Attribute):
                yield k,v
1193289
public void displayState() {
        PrintWriter xout = context.get(Log.outKey);
        xout.println("File Object History : " +  fileObjectHistory);
        xout.println("Open Type Names     : " +  openTypeNames);
        xout.println("Gen. Src Names      : " +  generatedSourceNames);
        xout.println("Gen. Cls Names      : " +  generatedClasses.keySet());
        xout.println("Agg. Gen. Src Names : " +  aggregateGeneratedSourceNames);
        xout.println("Agg. Gen. Cls Names : " +  aggregateGeneratedClassNames);
    }
860856
def _display(node, indent, expandattrs, expandvals, output):
    """"""
    attrs = _displayattrs(node.attrib, expandattrs)
    if node.text is None or not expandvals:
        val = ''
    elif isinstance(node.text, str):
        val = ' %s' % repr(node.text.strip())
    else:
        val = ' %s' % repr(node.text)  # node.text can be a tuple
    output.write(encode(indent + striptag(node.tag) + attrs + val + '\n'))
    for sub_node in node:
        _display(sub_node, indent + '  ', expandattrs, expandvals, output)
257529
def list(type)
      resource_class = parse_type(type)
      client_setup
      all = resource_class.get_all(@client)
      if options['attribute']
        data = select_attributes_from_multiple(options['attribute'], all)
        output data, -2 # Shift left by 2 so things look right
      else # List names only by default
        names = []
        all.each { |r| names.push(r['name']) }
        output names
      end
    end
1310827
def print(self, *objects, **kwargs):
		""""""
		file = kwargs.get("file")

		if file is not None and file is not sys.stdout:
			PRINT(*objects, **kwargs)

		else:
			sep = STR(kwargs.get("sep", " "))
			end = STR(kwargs.get("end", "\n"))

			text = sep.join(STR(o) for o in objects)

			self.imp_print(text, end)

		for callback in self.listeners:
			callback(text)
288330
def PrintAllTables(self):
    
    goodlogging.Log.Info("DB", "Database contents:\n")
    for table in self._tableDict.keys():
      self._PrintDatabaseTable(table)
1196637
def stats(self):
        
        printDebug("Classes.....: %d" % len(self.all_classes))
        printDebug("Properties..: %d" % len(self.all_properties))
193825
def info(self, show_defaults=False):
        
        pprinter = PrettyPrinter(show_options=True, show_defaults=show_defaults)
        print(pprinter.pprint(self._obj))
711977
def getAll(self):
        ''''''

        if not bool(len(self.ATTRIBUTES)):
            self.load_attributes()
        return eval(str(self.ATTRIBUTES))
1220356
def render_attrs(attrs):
    
    if attrs is not None:
        def parts():
            for key, value in sorted(attrs.items()):
                if value is None:
                    continue
                if value is True:
                    yield '%s' % (key, )
                    continue
                if key == 'class' and isinstance(value, dict):
                    if not value:
                        continue
                    value = render_class(value)
                if key == 'style' and isinstance(value, dict):
                    if not value:
                        continue
                    value = render_style(value)
                yield '%s="%s"' % (key, ('%s' % value).replace('"', '&quot;'))
        return mark_safe(' %s' % ' '.join(parts()))
    return ''
303396
private static void printNonAffectedClasses(Set<String> allClasses, Set<String> affectedClasses,
            List<String> nonAffectedClasses, String mode) {
        if (mode != null && mode.equals(ANT_MODE)) {
            StringBuilder sb = new StringBuilder();
            for (String className : nonAffectedClasses) {
                className = className.replaceAll("\\.", "/");
                sb.append("<exclude name=\"" + className + ".java\"/>");
            }
            System.out.println(sb);
        } else if (mode != null && mode.equals(MAVEN_SIMPLE_MODE)) {
            StringBuilder sb = new StringBuilder();
            for (String className : nonAffectedClasses) {
                className = className.replaceAll("\\.", "/");
                sb.append("<exclude>");
                sb.append(className).append(".java");
                sb.append("</exclude>");
            }
            System.out.println(sb);
        } else if (mode != null && mode.equals(MAVEN_MODE)) {
            StringBuilder sb = new StringBuilder();
            sb.append("<excludes>");
            for (String className : nonAffectedClasses) {
                className = className.replaceAll("\\.", "/");
                sb.append("<exclude>");
                sb.append(className).append(".java");
                sb.append("</exclude>");
            }
            sb.append("</excludes>");
            System.out.println(sb);
        } else if (mode != null && mode.equals(DEBUG_MODE)) {
            System.out.println("AFFECTED: " + affectedClasses);
            System.out.println("NONAFFECTED: " + nonAffectedClasses);
        } else {
            for (String className : nonAffectedClasses) {
                System.out.println(className);
            }
        }
    }