for string 'get_FIELD_NAME_display' return 'FIELD_NAME'
351201
def remove_getdisplay(field_name):
    '''
    
    '''
    str_ini = 'get_'
    str_end = '_display'
    if str_ini == field_name[0:len(str_ini)] and str_end == field_name[(-1) * len(str_end):]:
        field_name = field_name[len(str_ini):(-1) * len(str_end)]
    return field_name
899964
private static String getName(Opt option, Field field) {
        if (option.name().equals(Opt.DEFAULT_STRING)) {
            return field.getName();
        } else {
            return option.name();
        }
    }
93945
def _get_name(self, key):
        
        if key in self.display_names:
            return self.display_names[key]

        return key.capitalize()
1195995
def _get_internal_field_by_name(self, name):
        """"""
        field = self._all_fields.get(name, self._all_fields.get('%s.%s' % (self._full_name, name)))
        if field is not None:
            return field
        for field_name in self._all_fields:
            # Specific name
            if field_name.endswith('.%s' % name):
                return self._all_fields[field_name]
96675
def get_field_by_showname(self, showname):
        
        for field in self._get_all_fields_with_alternates():
            if field.showname_key == showname:
                # Return it if "XXX: whatever == XXX"
                return field
1320065
def getnodefieldname(idfobject, endswith, fluid=None, startswith=None):
    """"""
    if startswith is None:
        startswith = ''
    if fluid is None:
        fluid = ''
    nodenames = getfieldnamesendswith(idfobject, endswith)
    nodenames = [name for name in nodenames if name.startswith(startswith)]
    fnodenames = [nd for nd in nodenames if nd.find(fluid) != -1]
    fnodenames = [name for name in fnodenames if name.startswith(startswith)]
    if len(fnodenames) == 0:
        nodename = nodenames[0]
    else:
        nodename = fnodenames[0]
    return nodename
799607
def get_verbose_field_name(instance, field_name):
    
    fields = [field.name for field in instance._meta.fields]
    if field_name in fields:
        return instance._meta.get_field(field_name).verbose_name
    else:
        return field_name
249049
private static String getFieldName(Class<?> aClass,String regex){
		for (Field field : aClass.getDeclaredFields()) 
			if(field.getName().matches(regex)) 
				return field.getName();
		
		return null;
	}
1311573
def get_placeholder_field_names(self):
        
        return [field.name for field in self._meta.fields if field.get_internal_type() == 'PlaceholderField']
678841
def _sanitize_field_name(self, field_name):
        
        field_name = field_name.replace(self._field_prefix, '')
        return field_name.replace('.', '_').replace('-', '_').lower()
971669
def find_fields name
      res = {}
      @lines.each do | line |
        value = line.scan(/###{name}=<(.*)>/)
        if value[0]
          str = value[0][0]
          # p str
          v = VcfHeaderParser.parse_field(line,@debug)
          id = v['ID']
          res[id] = v
        end
      end
      # p res
      res
    end
1205668
def get_field_value(self, field, context):
        
        name = field.getName()
        value = context.getField(name).get(context)
        logger.info("get_field_value: context={} field={} value={}".format(
            context, name, value))
        return value
417544
def get_fieldname(self, field, arnum):
        
        name = field.getName()
        # ensure we have only *one* suffix
        base_name = name.split("-")[0]
        suffix = "-{}".format(arnum)
        return "{}{}".format(base_name, suffix)
911592
private static String getTypeName(FieldElement field) {
        DataType type = field.type();
        return type.toString();
    }
1106276
def get_field_name(self):
        
        if hasattr(self, 'agnocomplete_field') and \
           hasattr(self.agnocomplete_field, 'to_field_name'):
            return self.agnocomplete_field.to_field_name or 'pk'
        return 'pk'
1210513
def get_field_name(self, field):
        
        for field_name, f in self.fields.items():
            if f == field:
                return field_name
        raise AttributeError("Field %s does not exists in %s resource" % (
            field, self.__class__))
257949
def get_column_names(context, query):
        """"""
        table_info = context.sql_client.send(query)
        if 'fields' in table_info:
            return table_info['fields']

        return None