Returns a hashed value with data
162858
def getData(datadictionary_id)
      # /DataDictionaries/{ID}|{Name}/data
      parameter = { basic_auth: @auth }

      response = self.class.get("/datadictionaries/#{datadictionary_id}/data", parameter)
      if response.success?
        response['Data']
      else
        raise response.response
      end
    end
362088
def get_hash(self, handle):
        
        response = self.open_url(url=handle, suffix='.hash')
        try:
            return response.read()
        finally:
            response.close()
1079151
def to_hash(val)
      if @options[:humidity] then
        return {"humidity" => val.humidity}
      end

      if @options[:unit] == :c then
        if @options[:temperature] then
          return {"temperature" => val.temp}
        else
          return {"temperature" => val.temp, "humidity" => val.humidity}
        end
      else
        if @options[:temperature] then
          return {"temperature" => val.temp_f}
        else
          return {"temperature" => val.temp_f, "humidity" => val.humidity}
        end
      end
    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
704078
def hash_data(data, blocksize=65536):
    "
    data = pickle.dumps(data)

    hasher = hashlib.sha1()
    hasher.update(data)

    return hasher.hexdigest()
646235
def hash(self):
        """"""
        # Do not apply filters here (speed)
        hph = self.hparent.hash
        hpfilt = hashobj(self.hparent._filter)
        dhash = hashobj(hph + hpfilt)
        return dhash
793087
def hash(self):
        """"""
        h = hash_pandas_object(self, index=True)
        return hashlib.md5(h.values.tobytes()).hexdigest()
770710
def _get_hash(self, name, operation, create=False):
        
        return self._get_by_type(name, operation, create, b'hash', {})
458734
def _hash(self):
        
        dump = dumps(self.query, sort_keys=True)
        if isinstance(dump, str):
            dump = dump.encode('utf-8')
        return md5(dump).hexdigest()
259346
def hash(self):
        '''
        
        '''
        hashed = super(String, self).hash()
        return khash(hashed, self._max_size)
918723
function(value, $els) {
			value = hash_key(value);
	
			if (typeof value !== 'undefined' && value !== null) {
				for (var i = 0, n = $els.length; i < n; i++) {
					if ($els[i].getAttribute('data-value') === value) {
						return $($els[i]);
					}
				}
			}
	
			return $();
		}
1263910
def hash(self):
        """"""
        data_str = ';'.join(
            [str(repr(var)) for var in
             [self.N, self.K, self.X, self.L,
              self.stat, self.cutoff, self.pval,
              self.pval_thresh, self.escore_pval_thresh]])
        data_str += ';'
        data = data_str.encode('UTF-8') + self.indices.tobytes()
        return str(hashlib.md5(data).hexdigest())
1213304
def hash(self):
        '''
        
        '''
        hashed = super(Group, self).hash()
        return khash(hashed, frozenset(self._values))
93391
def to_hash
        h = {}
        keys.each { |k| h[ k ] = self.fetch( k ) }
        h
    end
104162
def hash(self):
        '''
        
        '''
        hashed = super(Compare, self).hash()
        return khash(hashed, self._comp_value, self._comp_type)
425647
def hash(self):
        '''
        
        '''
        hashed = super(_LibraryBitField, self).hash()
        return khash(hashed, self._length, self._signed, self._min_value, self._max_value)
247843
def hash(self):
        '''
        
        '''
        hashed = super(Container, self).hash()
        for f in self._fields:
            f_hashed = f.hash()
            hashed = khash(hashed + f_hashed)
        return hashed