Returns a suitable description of this field for South.
3862
def south_field_triple(self):
        
        # We'll just introspect the _actual_ field.
        from south.modelsinspector import introspector
        try:
            # Check if the field provides its own 'field_class':
            field_class = self.translated_field.south_field_triple()[0]
        except AttributeError:
            field_class = '%s.%s' % (self.translated_field.__class__.__module__,
                                     self.translated_field.__class__.__name__)
        args, kwargs = introspector(self)
        # That's our definition!
        return (field_class, args, kwargs)
1345816
def extent(self, srid=None):
        
        expr = self.geo_field.name
        if srid:
            expr = geofn.Transform(expr, srid)
        expr = models.Extent(expr)
        clone = self.all()
        name, val = clone.aggregate(expr).popitem()
        return val
953290
def get_field_description(f):
    """"""
    type_name = get_field_type(f)
    if type_name == 'MESSAGE' and \
            {sf.name for sf in f.message_type.fields} == {'key', 'value'}:
        return 'map<string, string>'
    elif type_name == 'MESSAGE':
        return f.message_type.full_name
    elif type_name == 'ENUM':
        return f.enum_type.full_name
    else:
        return type_name.lower()
810202
def get_srid(queryset):
    """"""
    try:
        srid = list(six.viewvalues(queryset.query.annotations))[0].srid
    except (AttributeError, IndexError):
        srid = None
    return srid or geo_field(queryset).srid
215594
public String getFieldDescription(int index)
    {
        ConstantInfo constantInfo = getConstantInfo(index);
        if (constantInfo instanceof Fieldref)
        {
            Fieldref fr = (Fieldref) getConstantInfo(index);
            int nt = fr.getName_and_type_index();
            NameAndType nat = (NameAndType) getConstantInfo(nt);
            int ni = nat.getName_index();
            int di = nat.getDescriptor_index();
            return getString(ni)+" "+getString(di);
        }
        return "unknown "+constantInfo;
    }
580656
def geo_description(self):
        """"""

        sc = self._p.space_coverage
        gc = self._p.grain_coverage

        if sc and gc:
            if parse_to_gvid(gc[0]).level == 'state' and parse_to_gvid(sc[0]).level == 'state':
                return parse_to_gvid(sc[0]).geo_name
            else:
                return ("{} in {}".format(
                    parse_to_gvid(gc[0]).level_plural.title(),
                    parse_to_gvid(sc[0]).geo_name))
        elif sc:
            return parse_to_gvid(sc[0]).geo_name.title()
        elif sc:
            return parse_to_gvid(gc[0]).level_plural.title()
        else:
            return ''
924446
public String getFieldDesc() 
    {
        if (m_convDescField != null)
            return m_convDescField.getFieldDesc();
        if ((m_strAltDesc == null) || (m_strAltDesc.length() == 0))
            return super.getFieldDesc();
        else
            return m_strAltDesc;
    }
1149806
public String describeDayOfMonth(final Map<CronFieldName, CronField> fields) {
        final String description = DescriptionStrategyFactory.daysOfMonthInstance(
                resourceBundle,
                fields.containsKey(CronFieldName.DAY_OF_MONTH) ? fields.get(CronFieldName.DAY_OF_MONTH).getExpression() : null
        ).describe();
        return addTimeExpressions(description, resourceBundle.getString("day"), resourceBundle.getString("days"));
    }
976459
def get_right_geo_fhs(self, dsid, fhs):
        """"""
        ds_info = self.ids[dsid]
        req_geo, rem_geo = self._get_req_rem_geo(ds_info)
        desired, other = split_desired_other(fhs, req_geo, rem_geo)
        if desired:
            try:
                ds_info['dataset_groups'].remove(rem_geo)
            except ValueError:
                pass
            return desired
        else:
            return other
912371
def getfield(self, pkt, buf):
        """"""
        self.set_endianess(pkt)
        return self.fld.getfield(pkt, buf)
706353
public static String[] getFieldDescription() {
		if(FIELDS == null){
			ArrayList<String> fields = new ArrayList<String>();
			for(Field field : KiekerTraceEntry.class.getDeclaredFields()){
				if(!Modifier.isStatic(field.getModifiers())){
					fields.add(field.getName());
				}
			}
			FIELDS = fields.toArray(new String[fields.size()]);
		}
		return FIELDS;
	}
1004712
def geo_field(queryset):
    """"""
    for field in queryset.model._meta.fields:
        if isinstance(field, models.GeometryField):
            return field
    raise exceptions.FieldDoesNotExist('No GeometryField found')
1234903
def descriptions(cls):
        
        schema = cls.json_get('%s/status/schema' % cls.api_url, empty_key=True,
                              send_key=False)
        descs = {}
        for val in schema['fields']['status']['value']:
            descs.update(val)
        return descs
18124
def description(self, platform, key):
        """"""
        patterns = self._dict_dscr.get(platform, None)
        description = patterns.get(key, None)
        return description
736190
function (fieldDefinition) {
		let type = fieldDefinition.fieldType;
		if (typeof type === 'object') {
			type = fieldDefinition.fieldType.type;
		}
		return type;
	}
1298624
def render_field_description(field):
    
    if hasattr(field, 'description') and field.description != '':
        html = """<p class="help-block">{field.description}</p>"""
        html = html.format(
            field=field
        )
        return HTMLString(html)
    
    return ''
687759
def _get_fields(self):
        
        if self.data is not None:
            return self.begin, self.end, self.data
        else:
            return self.begin, self.end