docs: def get_raw_entry(self, variant_line=None, variant_dict=None, 
      vcf_header=None, individual_id=None, dict_key=None):
          """Return the raw entry from the vcf field
              
              If no entry was found return None
              
              Args:
                  variant_line (str): A vcf formated variant line
                  vcf_header (list): A list with the vcf header line
                  individual_id (str): The individual id to get gt call
              Returns:
                  The raw entry found in variant line
          """
          if variant_line:
              variant_line = variant_line.rstrip().split()
          
          entry = None
          
          if self.field == 'CHROM':
              if variant_line:
                  entry = variant_line[0]
              elif variant_dict:
                  entry = variant_dict['CHROM']
                  
          elif self.field == 'POS':
              if variant_line:
                  entry = variant_line[1]
              elif variant_dict:
                  entry = variant_dict['POS']
              
          elif self.field == 'ID':
              if variant_line:
                  entry = variant_line[2]
              elif variant_dict:
                  entry = variant_dict['ID']
          
          elif self.field == 'REF':
              if variant_line:
                  entry = variant_line[3]
              elif variant_dict:
                  entry = variant_dict['REF']
          
          elif self.field == 'ALT':
              if variant_line:
                  entry = variant_line[4]
              elif variant_dict:
                  entry = variant_dict['ALT']
          
          elif self.field == 'QUAL':
              if variant_line:
                  entry = variant_line[5]
              elif variant_dict:
                  entry = variant_dict['QUAL']
          
          elif self.field == 'FILTER':
              if variant_line:
                  entry = variant_line[6]
              elif variant_dict:
                  entry = variant_dict['FILTER']
          
          elif self.field == 'INFO':
              if variant_line:
                  for info_annotation in variant_line[7].split(';'):
                      splitted_annotation = info_annotation.split('=')
                      if self.info_key == splitted_annotation[0]:
                          if len(splitted_annotation) == 2:
                              entry = splitted_annotation[1]
                              
              elif variant_dict:
                  entry = variant_dict.get('info_dict',{}).get(self.info_key)
              
              if self.dict_entry and entry:
                  #First we split the "dictionaries"
                  first_split = entry.split(self.separators[0])
                  for annotation in first_split:
                      # Then we search for the dict key
                      splitted_entry = annotation.split(self.separators[1])
                      key = splitted_entry[0] 
                      value = splitted_entry[1]
                      if dict_key:
                          if key == dict_key:
                              entry = value
                      #If no key we just return the last entry
                      else:
                          entry = value
              
          
          elif self.field == 'FORMAT':
              if variant_line:
                  entry = variant_line[8]
              elif variant_dict:
                  entry = variant_dict['FORMAT']
          
          elif self.field == "sample_id":
              
              if not individual_id:
                  raise IOError("If 'sample_id' a individual id must be provided")
              if not self.gt_key:
                  raise IOError("If 'sample_id' a genotype key must be provided")
              
              if variant_line:
                  if not vcf_header:
                      raise IOError("If 'sample_id' the vcf header must be provided")
                  
                  format_info = variant_line[8]
                  
                  for i, head in enumerate(vcf_header):
                      if head == individual_id:
                          raw_gt_call = variant_line[i]
              elif variant_dict:
                  format_info = variant_dict['FORMAT']
                  raw_gt_call = variant_dict[individual_id]
              
              entry_dict = dict(zip(
                  format_info.split(':'), raw_gt_call.split(':')
              ))
              entry = entry_dict.get(self.gt_key, '.')
          
          return entry