docs: def get_or_create_properties(self, graph: BELGraph, edge_data: EdgeData) -> Optional[List[Property]]:
          """Create a list of edge subject/object property models.
  
          Return None if the property cannot be constructed due to missing cache entries.
  
          :return: A list of all subject and object properties of the edge
          """
          property_list = []
          for participant in (SUBJECT, OBJECT):
              participant_data = edge_data.get(participant)
              if participant_data is None:
                  continue
  
              location = participant_data.get(LOCATION)
              if location is not None:
                  location_property_dict = {
                      'is_subject': participant == SUBJECT,
                      'modifier': LOCATION
                  }
  
                  location_namespace = location[NAMESPACE]
  
                  namespace_url = graph.namespace_url[location_namespace]
  
                  if namespace_url in graph.uncached_namespaces:
                      log.warning('uncached namespace %s in loc() on line %s', location_namespace,
                                  edge_data.get(LINE))
                      return
  
                  participant_name = location[NAME]
                  location_property_dict['effect'] = self.get_namespace_entry(namespace_url, participant_name)
                  if location_property_dict['effect'] is None:
                      raise IndexError('did not get {}: {}'.format(namespace_url, participant_name))
  
                  property_list.append(location_property_dict)
  
              modifier = participant_data.get(MODIFIER)
              if modifier is not None:
                  modifier_property_dict = {
                      'is_subject': participant == SUBJECT,
                      'modifier': modifier
                  }
  
                  if modifier == TRANSLOCATION:
                      for effect_type, effect_value in participant_data.get(EFFECT, {}).items():
                          tmp_dict = deepcopy(modifier_property_dict)
                          tmp_dict['relative_key'] = effect_type
  
                          if NAMESPACE not in effect_value:
                              tmp_dict['propValue'] = effect_value
                              raise ValueError('shouldnt use propValue')
                          else:
                              effect_namespace = effect_value[NAMESPACE]
  
                              if effect_namespace in graph.namespace_url:
                                  namespace_url = graph.namespace_url[effect_namespace]
                              elif effect_namespace == BEL_DEFAULT_NAMESPACE:
                                  namespace_url = BEL_DEFAULT_NAMESPACE_URL
                              else:
                                  log.warning('namespace not enumerated in modifier %s', effect_namespace)
                                  return
  
                              if namespace_url in graph.uncached_namespaces:
                                  log.warning('uncached namespace %s in tloc() on line %s ', effect_namespace,
                                              edge_data.get(LINE))
                                  return
  
                              effect_name = effect_value[NAME]
                              tmp_dict['effect'] = self.get_namespace_entry(namespace_url, effect_name)
  
                              if tmp_dict['effect'] is None:
                                  log.warning('could not find tloc() %s %s', namespace_url, effect_name)
                                  return  # FIXME raise?
  
                          property_list.append(tmp_dict)
  
                  elif modifier == ACTIVITY:
                      effect = participant_data.get(EFFECT)
                      if effect is not None:
                          namespace_url = _normalize_url(graph, effect[NAMESPACE])
  
                          if namespace_url in graph.uncached_namespaces:
                              log.warning('uncached namespace %s in fusion()', namespace_url)
                              return
  
                          modifier_property_dict['effect'] = self.get_namespace_entry(namespace_url, effect[NAME])
  
                      property_list.append(modifier_property_dict)
  
                  elif modifier == DEGRADATION:
                      property_list.append(modifier_property_dict)
  
                  else:
                      raise ValueError('unknown modifier: {}'.format(modifier))
  
          return [
              self._make_property_from_dict(property_def)
              for property_def in property_list
          ]