docs: def get_value(self, variant_line=None, variant_dict=None, entry=None, 
          raw_entry=None, vcf_header=None, csq_format=None, dict_key=None, 
          individual_id=None):
          """
          Return the value as specified by plugin
          
          Get value will return one value or None if no correct value is found.
          
          Arguments:
              variant_line (str): A vcf variant line
              variant_dict (dict): A variant dictionary
              entry (list): A splitted entry
              raw_entry (str): The raw entry from the vcf file
              vcf_header (list): The vcf header line with sample ids
              csq_format (list): The CSQ format
              family_id (str): The family id
              individual_id (str): The individual id
          
          Returns:
              value (str): A string that represents the correct value
          
          """
          value = None
          
          raw_entry = self.get_raw_entry(
              variant_line = variant_line, 
              variant_dict = variant_dict, 
              vcf_header=vcf_header, 
              individual_id=individual_id,
              dict_key=dict_key
          )
          # If data type is flag we only need to check if any entry exists
          if self.data_type == 'flag':
              if self.field == 'INFO':
                  if variant_line:
                      for info_entry in variant_line.split()[7].split(';'):
                          if self.info_key == info_entry.split('=')[0]:
                              value = True
                  elif variant_dict:
                      if self.info_key in variant_dict.get('info_dict',{}):
                          value = True
              else:
                  if raw_entry != '.':
                      value = True
          
          # If we have a record rule we need to return the correct value
          elif raw_entry:
          # If there was no raw entry we will return None
              if self.record_rule:
              
                  if self.data_type == 'string':
                  
                      if self.record_rule == 'max':
                          sorted_strings = sorted(
                              self.string_rules.items(), 
                              key=operator.itemgetter(1), 
                              reverse=True
                          )
                      
                      if self.record_rule == 'min':
                          sorted_strings = sorted(
                              self.string_rules.items(), 
                              key=operator.itemgetter(1)
                          )
                      
                      for string_rule in sorted_strings:
                          if string_rule[0].lower() in raw_entry.lower():
                              value = string_rule[0]
                              break
                  else:
                      
                      typed_annotations = []
                      
                      for value in self.get_entry(
                          raw_entry=raw_entry,
                          vcf_header=vcf_header, 
                          csq_format=csq_format, 
                          dict_key=dict_key, 
                          individual_id=individual_id):
                  
                          if self.data_type == 'float':
                              try:
                                  typed_annotations.append(float(value))
                              except ValueError:
                                  pass
                      
                          elif self.data_type == 'integer':
                              try:
                                  typed_annotations.append(int(value))
                              except ValueError:
                                  pass
                  
                      if typed_annotations:
                          if self.record_rule == 'max':
                              value = max(typed_annotations)
                      
                          elif self.record_rule == 'min':
                              value = min(typed_annotations)
                      else:
                          value = None
          
              # If no record rule is given we return the raw annotation
              # Here the data_type is not flag, and there is no record rule
              # We know that there exists a raw annotation
              else:
                  # We will just return the first annotation found
                  value = self.get_entry(
                          raw_entry=raw_entry,
                          vcf_header=vcf_header, 
                          csq_format=csq_format, 
                          dict_key=dict_key, 
                          individual_id=individual_id)[0]
                  
                  if self.data_type == 'float':
                          try:
                              value = float(value)
                          except ValueError:
                              pass
                      
                  elif self.data_type == 'integer':
                      try:
                          value = int(value)
                      except ValueError:
                          pass
          
          return value