:rtype: int
        :return: hash of the field
766098
def hash(self):
        '''
        
        '''
        hashed = super(Calculated, self).hash()
        return khash(hashed, self._field_name)
340873
def _get_field(instance, field):
    
    
    value = getattr(instance, field)
    if hasattr(value, 'raw'):
        value = value.raw
    return value
1275412
def get_keys_for(self, value):
        
        if callable(value):
            return value(self)
        hash_value = self.get_hash_for(value)
        return self._index[hash_value][:]
430166
def fast_hash(self):
        
        fast = sum(i.fast_hash() for i in self.data.values())
        return fast
1031570
def hashone(self):
    ""
    rs = self.one()
    if not rs: 
      return {}
    else:
      finds = " ".join(self._find).split(' ')
      return dict(zip((x.replace('?','') for x in finds), rs))
693670
def sha256(self):
        

        if self._sha256 is None:
            self._sha256 = hashlib.sha256(self.dump()).digest()
        return self._sha256
267498
def hash_name(self):
        
        name = self._item.get("market_hash_name")

        if not name:
            name = "{0.appid}-{0.name}".format(self)

        return name
496785
def to_hash
      keys = table_header_keys
      values = self
      hash = {}
      keys.each_with_index {|k,i| hash[k]=values[i]}
      return hash
    end
265810
def result(self):
         
        field = re.sub(REGEX_CLEANER, '', self.field_name)

        if self.alias:
            alias = re.sub(REGEX_CLEANER, '', self.alias)
            return "%s AS %s" % (field, alias)
        else:
            return field
141348
def to_hash
      out = {}
      self.class.properties.each { |p| out[hash_key(p)] = hash_value(p) }
      out
    end
527220
def sha_hash(self) -> str:
        
        return hashlib.sha256(self.signed_raw().encode("ascii")).hexdigest().upper()
1264438
def hash(self):
        """"""
        content = json.dumps(self.data, sort_keys=True, separators=(",", ":"))
        return hashlib.sha256(content.encode("utf8")).hexdigest()
634372
def to_hash()
      ret_hash = {}
      self.class.json_attributes.each do |attrib|
        ret_hash[attrib] = self.send(attrib.to_s.underscore)
      end
      return ret_hash
    end
664583
def to_hash
      result = {}

      @values.keys.each do |field_name|
        value = __send__(field_name)
        hashed_value = value.respond_to?(:to_hash_value) ? value.to_hash_value : value
        result.merge!(field_name => hashed_value)
      end

      result
    end
479418
def to_hash
      hash = {}
      instance_variables.each do |name|
        value = instance_variable_get(name)
        next if value.nil?
        name = name[1..-1]
        key = self.class.names.key?(name) ? self.class.names[name] : name
        if value.instance_of? Array
          hash[key] = value.map { |v| v.is_a?(BaseModel) ? v.to_hash : v }
        elsif value.instance_of? Hash
          hash[key] = {}
          value.each do |k, v|
            hash[key][k] = v.is_a?(BaseModel) ? v.to_hash : v
          end
        else
          hash[key] = value.is_a?(BaseModel) ? value.to_hash : value
        end
      end
      hash
    end
672697
def to_query(self):
        
        query = {}

        for field_instance in self.fields:
            query.update(field_instance.to_query())

        return query
93391
def to_hash
        h = {}
        keys.each { |k| h[ k ] = self.fetch( k ) }
        h
    end