docs: def get_or_create_modification(self, graph: BELGraph, node: BaseEntity) -> Optional[List[Modification]]:
          """Create a list of node modification objects that belong to the node described by node_data.
  
          Return ``None`` if the list can not be constructed, and the node should also be skipped.
  
          :param dict node: Describes the given node and contains is_variant information
          :return: A list of modification objects belonging to the given node
          """
          modification_list = []
          if FUSION in node:
              mod_type = FUSION
              node = node[FUSION]
              p3_namespace_url = graph.namespace_url[node[PARTNER_3P][NAMESPACE]]
  
              if p3_namespace_url in graph.uncached_namespaces:
                  log.warning('uncached namespace %s in fusion()', p3_namespace_url)
                  return
  
              p3_name = node[PARTNER_3P][NAME]
              p3_namespace_entry = self.get_namespace_entry(p3_namespace_url, p3_name)
  
              if p3_namespace_entry is None:
                  log.warning('Could not find namespace entry %s %s', p3_namespace_url, p3_name)
                  return  # FIXME raise?
  
              p5_namespace_url = graph.namespace_url[node[PARTNER_5P][NAMESPACE]]
  
              if p5_namespace_url in graph.uncached_namespaces:
                  log.warning('uncached namespace %s in fusion()', p5_namespace_url)
                  return
  
              p5_name = node[PARTNER_5P][NAME]
              p5_namespace_entry = self.get_namespace_entry(p5_namespace_url, p5_name)
  
              if p5_namespace_entry is None:
                  log.warning('Could not find namespace entry %s %s', p5_namespace_url, p5_name)
                  return  # FIXME raise?
  
              fusion_dict = {
                  'type': mod_type,
                  'p3_partner': p3_namespace_entry,
                  'p5_partner': p5_namespace_entry,
              }
  
              node_range_3p = node.get(RANGE_3P)
              if node_range_3p and FUSION_REFERENCE in node_range_3p:
                  fusion_dict.update({
                      'p3_reference': node_range_3p[FUSION_REFERENCE],
                      'p3_start': node_range_3p[FUSION_START],
                      'p3_stop': node_range_3p[FUSION_STOP],
                  })
  
              node_range_5p = node.get(RANGE_5P)
              if node_range_5p and FUSION_REFERENCE in node_range_5p:
                  fusion_dict.update({
                      'p5_reference': node_range_5p[FUSION_REFERENCE],
                      'p5_start': node_range_5p[FUSION_START],
                      'p5_stop': node_range_5p[FUSION_STOP],
                  })
  
              modification_list.append(fusion_dict)
  
          else:
              for variant in node[VARIANTS]:
                  mod_type = variant[KIND].strip()
                  if mod_type == HGVS:
                      modification_list.append({
                          'type': mod_type,
                          'variantString': variant[IDENTIFIER]
                      })
  
                  elif mod_type == FRAGMENT:
                      if FRAGMENT_MISSING in variant:
                          modification_list.append({
                              'type': mod_type,
                          })
                      else:
                          modification_list.append({
                              'type': mod_type,
                              'p3_start': variant[FRAGMENT_START],
                              'p3_stop': variant[FRAGMENT_STOP]
                          })
  
                  elif mod_type in {GMOD, PMOD}:
                      variant_identifier = variant[IDENTIFIER]
                      namespace_url = _normalize_url(graph, variant_identifier[NAMESPACE])
  
                      if namespace_url in graph.uncached_namespaces:
                          log.warning('uncached namespace %s in fusion()', namespace_url)
                          return
  
                      mod_entry = self.get_namespace_entry(namespace_url, variant_identifier[NAME])
  
                      if mod_type == GMOD:
                          modification_list.append({
                              'type': mod_type,
                              'identifier': mod_entry
                          })
                      if mod_type == PMOD:
                          modification_list.append({
                              'type': mod_type,
                              'identifier': mod_entry,
                              'residue': variant[PMOD_CODE].strip() if PMOD_CODE in variant else None,
                              'position': variant[PMOD_POSITION] if PMOD_POSITION in variant else None
                          })
  
          modifications = []
          for modification in modification_list:
              mod_hash = hash_dump(modification)
  
              mod = self.object_cache_modification.get(mod_hash)
              if mod is None:
                  mod = self.get_modification_by_hash(mod_hash)
                  if not mod:
                      modification['sha512'] = mod_hash
                      mod = Modification(**modification)
  
                  self.object_cache_modification[mod_hash] = mod
              modifications.append(mod)
  
          return modifications