Return the value of the field in entity (or ``None``).
552814
def _get_value_for_serialization(self, data, name, spec):
        
        name = self.property_name_map[name]
        return getattr(data, name, None)
799377
def get_value(self, item, default=None):
        """"""
        try:
            return self[item].value
        except (AttributeError, KeyError) as e:
            return default
351959
def get_by_entityid(self, entityid):
		
		data = self.list(entityid=entityid)
		if len(data) == 0:
			return None

		eid = int( next(iter(data)) )
		entity = self.get(eid)

		self.debug(0x01,entity)
		return entity
407306
def _return_value(content, ns):
    
    doc = ElementTree.fromstring(content)
    query = './/{%(ns)s}%(item)s' % {'ns': ns, 'item': 'ReturnValue'}
    rv = doc.find(query)
    return int(rv.text)
1272867
def extract_entity(found):
    """"""
    obj = dict()
    for prop in found.entity.property:
        obj[prop.name] = prop.value.string_value
    return obj
398901
def get_value(row, field_name):
    '''
    
    '''
    result = None
    dict_row = convert_to_dict(row)
    if detect_list(field_name):
        temp = row
        for field in field_name:
            dict_temp = convert_to_dict(temp)
            temp = dict_temp.get(field, None)
        result = temp
    else:
        result = dict_row.get(field_name, None)
    return result
563703
def get_value(cls, object_version, key):
        """"""
        obj = cls.get(object_version, key)
        return obj.value if obj else None
437949
def get_field_by_name(self, name):
        

        for f in self.fields:
            if f.get_name() == name:
                return f
        return None
446265
def get_value(self, field):
        '''
        
        '''
        if field not in self._field_generators:
            self._field_generators[field] = self.get_generator(field)
        generator = self._field_generators[field]
        if generator is None:
            return self.IGNORE_FIELD
        value = generator()
        return value
823603
private Object getColumnValue(String column, ENTITY entity) {
        Method getter = orMapping.getGetter(column);
        try {
            return getter.invoke(entity);
        } catch (Exception e) {
            throw new RuntimeException();
        }
    }
1225133
def get(self, key, defaultValue=None):
        """"""
        if defaultValue is None:   # Py4J doesn't call the right get() if we pass None
            if self._jconf is not None:
                if not self._jconf.contains(key):
                    return None
                return self._jconf.get(key)
            else:
                if key not in self._conf:
                    return None
                return self._conf[key]
        else:
            if self._jconf is not None:
                return self._jconf.get(key, defaultValue)
            else:
                return self._conf.get(key, defaultValue)
1118881
def get_method_returning_field_value(self, field_name):
        
        method = getattr(self, field_name, None)
        return method if method and callable(method) else None
975817
def get_by(self, field, value):
        
        return self._client.get_by(field=field, value=value)
1247590
def get_field(field):
    """"""
    if isinstance(field, djmodels.fields.Field):
        return field
    elif isinstance(field, basestring):
        field = field.split('.')
        if len(field) == 3:
            model = get_model(app=field[0], model=field[1])
        elif len(field) == 2:
            model = get_model(app=DEFAULT_APP, model=field[0])
        else:
            return None
            raise NotImplementedError("Unknown default model name. Don't know where to look for field %s" % '.'.join(field)) 
        field = model._meta.get_field(field[-1])
    return field
726023
def localize_field(self, value):
        
        if self.default is not None:
            if value is None or value == '':
                value = self.default
        return value or ''
499841
protected function getEntityAttributeValue($entity, $field)
    {
        $functionName = 'get'.ucfirst($field);

        $fieldValue = call_user_func([$entity, $functionName]);

        return $fieldValue;
    }
725333
def _get_value(self, node, scope, ctxt, stream):
        

        res = self._handle_node(node, scope, ctxt, stream)

        if isinstance(res, fields.Field):
            return res._pfp__value

        # assume it's a constant
        else:
            return res