Returns a list with the bad aspects the object
        makes to the malefics.
181014
def aspectMalefics(self):
        
        malefics = [const.MARS, const.SATURN]
        return self.__aspectLists(malefics, aspList=[0, 90, 180])
1359613
public static List qualityList(Enumeration enm)
    {
        if(enm==null || !enm.hasMoreElements())
            return Collections.EMPTY_LIST;

        Object list=null;
        Object qual=null;

        // Assume list will be well ordered and just add nonzero
        while(enm.hasMoreElements())
        {
            String v=enm.nextElement().toString();
            Float q=getQuality(v);

            if (q.floatValue()>=0.001)
            {
                list=LazyList.add(list,v);
                qual=LazyList.add(qual,q);
            }
        }

        List vl=LazyList.getList(list,false);
        if (vl.size()<2)
            return vl;

        List ql=LazyList.getList(qual,false);

        // sort list with swaps
        Float last=__zero;
        for (int i=vl.size();i-->0;)
        {
            Float q = (Float)ql.get(i);
            if (last.compareTo(q)>0)
            {
                Object tmp=vl.get(i);
                vl.set(i,vl.get(i+1));
                vl.set(i+1,tmp);
                ql.set(i,ql.get(i+1));
                ql.set(i+1,q);
                last=__zero;
                i=vl.size();
                continue;
            }
            last=q;
        }
        ql.clear();
        return vl;
    }
1041467
def aspectBenefics(self):
        
        benefics = [const.VENUS, const.JUPITER]
        return self.__aspectLists(benefics, aspList=[0, 60, 120])
3816
def items(self):
        ""
        return (list(self._pb.IntMap.items()) + list(self._pb.StringMap.items()) +
                list(self._pb.FloatMap.items()) + list(self._pb.BoolMap.items()))
358616
def items(self):
        """"""
        return list(zip((self.scalars + self.sections), list(self.values())))
622681
def get_object_errors(self):
        
        if self._object_errors is None:
            self._object_errors = [{str(o): o.get_errors()}
                                   for o in self.objects()
                                   if o.has_error()]

        return self._object_errors
1159918
def features(self):
        
        result = []
        features = self._safe_get_element('ItemAttributes.Feature')
        if features is not None:
            for feature in features:
                result.append(feature.text)
        return result
308125
def object_attributes( thing, all=False ) :
    '''
    
    '''
    standard_names = set( dir( object() ) )
    things_names = set( dir( thing ) )
    if not all :
        things_names -= standard_names
        things_names |= set( ['__doc__'] )
    return sorted( things_names )
1073925
def items(cls):
        
        return [
            cls.GREEN,
            cls.BLACK_AND_WHITE,
            cls.CONTRAST_SHIFTED,
            cls.CONTRAST_CONTINUOUS
        ]
819263
def p_state_cons_list(self, p):
        ''''''
        if len(p) == 3:
            p[1].append(p[2])
            p[0] = p[1]
        elif len(p) == 2:
            p[0] = [p[1]]
488801
def get_impediments():
    
    file = urlopen(XML_URL)

    doc = dom.parse(file)
    xml = doc.documentElement

    nodes = xml.getElementsByTagName('utr')
    impediments = [extract(node) for node in nodes]

    return impediments
334576
def get_issues():
        """"""
        issues = []
        for entry in Logger.journal:
            if entry.level >= WARNING:
                issues.append(entry)
        return issues
993752
def fields(self):
        """"""
        return (self.attributes.values() + self.lists.values()
                + self.references.values())
1120683
def pretty_print_list(lst, name = 'features', repr_format=True):
    
    if not lst or len(lst) < 8:
        if repr_format:
            return lst.__repr__()
        else:
            return ', '.join(map(str, lst))
    else:
        topk = ', '.join(map(str, lst[:3]))
        if repr_format:
            lst_separator = "["
            lst_end_separator = "]"
        else:
            lst_separator = ""
            lst_end_separator = ""

        return "{start}{topk}, ... {last}{end} (total {size} {name})".format(\
                topk = topk, last = lst[-1], name = name, size = len(lst),
                start = lst_separator, end = lst_end_separator)
205550
public Collection<String> readableProps(Object m) {
		LinkedList<String> res = new LinkedList<String>();
		for(PropertyDescriptor pd : info(m).getPropertyDescriptors()) {
			Method getter = pd.getReadMethod();
			String prop = pd.getName();
			if(getter != null && ! skipProps.contains(prop)) {
				res.add(prop);
			}
		}
		return res;
	}
432133
def pretty_print(self, warnings=False):
        
        msg = []
        if (warnings) and (len(self.warnings) > 0):
            msg.append(u"Warnings:")
            for warning in self.warnings:
                msg.append(u"  %s" % warning)
        if len(self.errors) > 0:
            msg.append(u"Errors:")
            for error in self.errors:
                msg.append(u"  %s" % error)
        return u"\n".join(msg)
505814
public List<ErrorPageType<WebAppDescriptor>> getAllErrorPage()
   {
      List<ErrorPageType<WebAppDescriptor>> list = new ArrayList<ErrorPageType<WebAppDescriptor>>();
      List<Node> nodeList = model.get("error-page");
      for(Node node: nodeList)
      {
         ErrorPageType<WebAppDescriptor>  type = new ErrorPageTypeImpl<WebAppDescriptor>(this, "error-page", model, node);
         list.add(type);
      }
      return list;
   }