Get head block header.

        :return:
328459
def _get_head_block(self):
        
        if not self.head_block_header:
            block_hash = self.db.get(head_header_key)
            num = self._get_block_number(block_hash)
            self.head_block_header = self._get_block_header(block_hash, num)
            # find header with valid state
            while (
                not self.db.get(self.head_block_header.state_root)
                and self.head_block_header.prevhash is not None
            ):
                block_hash = self.head_block_header.prevhash
                num = self._get_block_number(block_hash)
                self.head_block_header = self._get_block_header(block_hash, num)

        return self.head_block_header
1047940
def head(self, bytes):
        
        oldpos = self.io.tell()
        self.io.seek(0)
        head = self.io.read(bytes)
        self.io.seek(oldpos)
        return head
1223081
function getCurrentHeader (tree) {
  const heading = []
  while (headIsH2(tree.children) === false && tree.children.length > 0) {
    heading.push(tree.children.shift())
  }
  return heading
}
1011091
def get(self):
        
        header = {}
        if self.key is not None and self.value is not None:
            header[self.key] = self.value
        return header
1246352
def header(self):
        """"""
        tracks = a2b_hex('%04x' % len([t for t in self.tracks if
            t.track_data != '']))
        return 'MThd\x00\x00\x00\x06\x00\x01' + tracks + self.time_division
1145490
def _get_block(self):
    """"""
    b = self._fh.read(4) # get block size bytes
    #print self._fh.tell()
    if not b: raise StopIteration
    block_size = struct.unpack('<i',b)[0]
    return self._fh.read(block_size)
591792
def _get_header(self, header):
        
        if header is None:
            html = self.header()
        else:
            html = header
        return html
278213
def get_header(cls, script_text="", executable=None):
        """"""
        cmd = cls.command_spec_class.best().from_param(executable)
        cmd.install_options(script_text)
        return cmd.as_header()
243768
def head(self, wg_uuid, uuid):
        
        url = "%(base)s/%(wg_uuid)s/nodes/%(uuid)s" % {
            'base': self.local_base_url,
            'wg_uuid': wg_uuid,
            'uuid': uuid
        }
        # return self.core.head(url)
        try:
            # workaround
            return self.core.get(url)
        except LinShareException:
            return False
1087437
def _get_block_header(self, block_hash, num):
        
        header_key = header_prefix + num + block_hash

        block_header_data = self.db.get(header_key)
        header = rlp.decode(block_header_data, sedes=BlockHeader)
        return header
1108912
def getheader(self, name, default=None):
        
        return self.response.headers.get(name, default)
652560
def header_output(self):
        '''
        '''
        result = []
        for key in self.keys():
            result.append(key + '=' + self.get(key).value)
        return '; '.join(result)
717059
public Token getHead() {
    if (DependencyRelation_Type.featOkTst && ((DependencyRelation_Type)jcasType).casFeat_head == null)
      jcasType.jcas.throwFeatMissing("head", "de.julielab.jules.types.DependencyRelation");
    return (Token)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefValue(addr, ((DependencyRelation_Type)jcasType).casFeatCode_head)));}
502123
def get_header(results):
    ''''''
    ret = ['name', ]
    values = next(iter(results.values()))
    for k, v in values.items():
        if isinstance(v, dict):
            for metric in v.keys():
                ret.append('%s:%s' % (k, metric))
        else:
            ret.append(k)
    return ret
1368222
def get_auth_header(self):
        
        if self.api.is_authenticated:
            return {"Authorization": "Bearer %s" % self.api.access_token}
        return {"Authorization": "Client-ID %s" % self.api.client_id}
1295801
def header(self):
    """"""
    return struct.pack(
        self.HEADER_STRUCT_FORMAT, self._command, self.arg0, self.arg1,
        len(self.data), self.data_crc32, self.magic)
982242
def get_header(headers, name, default=None):
    
    name = name.lower()
    for header in headers:
        if header[0].lower() == name:
            return header[1]
    return default