Parsers

Functions for parsing SSSOM files from various formats.

sssom.parsers

SSSOM parsers.

parse_sssom_table(file_path, prefix_map=None, meta=None, *, strict=False, sep=None, propagate=True, **kwargs)

Parse a SSSOM CSV or TSV file.

:param file_path: A file path, URL, or I/O object that contains SSSOM encoded in TSV :param prefix_map: A prefix map or :class:curies.Converter used to validate prefixes, CURIEs, and IRIs appearing in the SSSOM TSV :param meta: Additional document-level metadata for the SSSOM TSV document that is not contained within the document itself. For example, this may come from a companion SSSOM YAML file. :param strict: If true, will fail parsing for undefined prefixes, CURIEs, or IRIs :param sep: The seperator. If not given, inferred from file name :param propagate: If true, propagate all condensed slots. :param kwargs: Additional keyword arguments (unhandled)

:returns: A parsed dataframe wrapper object

Source code in src/sssom/parsers.py

def parse_sssom_table(
    file_path: PathOrIO,
    prefix_map: ConverterHint | None = None,
    meta: Optional[MetadataType] = None,
    *,
    strict: bool = False,
    sep: Optional[str] = None,
    propagate: bool = True,
    **kwargs: Any,
) -> MappingSetDataFrame:
    """Parse a SSSOM CSV or TSV file.

    :param file_path: A file path, URL, or I/O object that contains SSSOM encoded in TSV
    :param prefix_map: A prefix map or :class:`curies.Converter` used to validate prefixes, CURIEs,
        and IRIs appearing in the SSSOM TSV
    :param meta: Additional document-level metadata for the SSSOM TSV document that is not contained
        within the document itself. For example, this may come from a companion SSSOM YAML file.
    :param strict: If true, will fail parsing for undefined prefixes, CURIEs, or IRIs
    :param sep: The seperator. If not given, inferred from file name
    :param propagate: If true, propagate all condensed slots.
    :param kwargs: Additional keyword arguments (unhandled)

    :returns: A parsed dataframe wrapper object
    """
    if kwargs:
        logging.warning("unhandled keyword arguments passed: %s", kwargs)

    df, sssom_metadata = _read_pandas_and_metadata(file_path, sep)
    if meta is None:
        meta = {}

    is_valid_built_in_prefixes = _check_redefined_builtin_prefixes(sssom_metadata, meta, prefix_map)
    is_valid_metadata = _is_irregular_metadata([sssom_metadata, meta])

    if strict:
        _fail_in_strict_parsing_mode(is_valid_built_in_prefixes, is_valid_metadata)

    # The priority order for combining prefix maps are:
    #  1. Built-in prefix map
    #  2. Internal prefix map inside the document
    #  3. Prefix map passed through this function inside the ``meta``
    #  4. Prefix map passed through this function to ``prefix_map`` (handled with ensure_converter)
    converter = curies.chain(
        [
            _get_built_in_prefix_map(),
            Converter.from_prefix_map(sssom_metadata.pop(CURIE_MAP, {})),
            Converter.from_prefix_map(meta.pop(CURIE_MAP, {})),
            ensure_converter(prefix_map, use_defaults=False),
        ]
    )

    # The priority order for combining metadata is:
    #  1. Metadata appearing in the SSSOM document
    #  2. Metadata passed through ``meta`` to this function
    #  3. Default metadata
    combine_meta = dict(
        ChainMap(
            sssom_metadata,
            meta,
            get_default_metadata(),
        )
    )

    if propagate:
        propagate_condensed_slots(df, combine_meta)

    msdf = from_sssom_dataframe(df, prefix_map=converter, meta=combine_meta)
    return msdf

parse_csv(*args, **kwargs)

Parse a SSSOM CSV file, forwarding arguments to :func:parse_sssom_table.

Source code in src/sssom/parsers.py

def parse_csv(*args: Any, **kwargs: Any) -> MappingSetDataFrame:
    """Parse a SSSOM CSV file, forwarding arguments to :func:`parse_sssom_table`."""
    kwargs["sep"] = ","
    return parse_sssom_table(*args, **kwargs)

parse_tsv(*args, **kwargs)

Parse a SSSOM TSV file, forwarding arguments to :func:parse_sssom_table.

Source code in src/sssom/parsers.py

def parse_tsv(*args: Any, **kwargs: Any) -> MappingSetDataFrame:
    """Parse a SSSOM TSV file, forwarding arguments to :func:`parse_sssom_table`."""
    kwargs["sep"] = "\t"
    return parse_sssom_table(*args, **kwargs)

parse_sssom_rdf(file_path, prefix_map=None, meta=None, serialisation=SSSOM_DEFAULT_RDF_SERIALISATION, propagate=True, **kwargs)

Parse a TSV to a :class:MappingSetDocument to a :class:MappingSetDataFrame.

Source code in src/sssom/parsers.py

def parse_sssom_rdf(
    file_path: Union[str, Path],
    prefix_map: ConverterHint = None,
    meta: Optional[MetadataType] = None,
    serialisation: str = SSSOM_DEFAULT_RDF_SERIALISATION,
    propagate: bool = True,
    **kwargs: Any,
    # mapping_predicates: Optional[List[str]] = None,
) -> MappingSetDataFrame:
    """Parse a TSV to a :class:`MappingSetDocument` to a :class:`MappingSetDataFrame`."""
    raise_for_bad_path(file_path)

    g = Graph()
    g.parse(file_path, format=serialisation)

    # Initialize meta if it's None
    if meta is None:
        meta = {}

    # The priority order for combining prefix maps are:
    #  1. Built-in prefix map
    #  2. Internal prefix map inside the document
    #  3. Prefix map passed through this function inside the ``meta``
    #  4. Prefix map passed through this function to ``prefix_map`` (handled with ensure_converter)
    converter = curies.chain(
        [
            _get_built_in_prefix_map(),
            Converter.from_rdflib(g),
            Converter.from_prefix_map(meta.pop(CURIE_MAP, {})),
            ensure_converter(prefix_map, use_defaults=False),
        ]
    )
    msdf = from_sssom_rdf(g, prefix_map=converter, meta=meta)
    if propagate:
        msdf.propagate()
    # df: pd.DataFrame = msdf.df
    # if mapping_predicates and not df.empty():
    #     msdf.df = df[df["predicate_id"].isin(mapping_predicates)]
    return msdf

parse_sssom_json(file_path, prefix_map=None, meta=None, propagate=True, **kwargs)

Parse a TSV to a :class:MappingSetDocument to a :class:MappingSetDataFrame.

Source code in src/sssom/parsers.py

def parse_sssom_json(
    file_path: Union[str, Path],
    prefix_map: ConverterHint = None,
    meta: Optional[MetadataType] = None,
    propagate: bool = True,
    **kwargs: Any,
) -> MappingSetDataFrame:
    """Parse a TSV to a :class:`MappingSetDocument` to a :class:`MappingSetDataFrame`."""
    raise_for_bad_path(file_path)

    with open(file_path) as json_file:
        jsondoc = json.load(json_file)

    # Initialize meta if it's None
    if meta is None:
        meta = {}

    # The priority order for combining prefix maps are:
    #  1. Built-in prefix map
    #  2. Internal prefix map inside the document
    #  3. Prefix map passed through this function inside the ``meta``
    #  4. Prefix map passed through this function to ``prefix_map`` (handled with ensure_converter)
    converter = curies.chain(
        [
            _get_built_in_prefix_map(),
            Converter.from_jsonld(file_path),
            Converter.from_prefix_map(meta.pop(CURIE_MAP, {})),
            ensure_converter(prefix_map, use_defaults=False),
        ]
    )

    msdf = from_sssom_json(jsondoc=jsondoc, prefix_map=converter, meta=meta)
    if propagate:
        msdf.propagate()
    return msdf

parse_obographs_json(file_path, prefix_map=None, meta=None, mapping_predicates=None, propagate=False)

Parse an obographs file as a JSON object and translates it into a MappingSetDataFrame.

:param file_path: The path to the obographs file :param prefix_map: an optional prefix map :param meta: an optional dictionary of metadata elements :param mapping_predicates: an optional list of mapping predicates that should be extracted :param propagate: If true, propagate all condensed slots.

:returns: A SSSOM MappingSetDataFrame

Source code in src/sssom/parsers.py

def parse_obographs_json(
    file_path: Union[str, Path],
    prefix_map: ConverterHint = None,
    meta: Optional[MetadataType] = None,
    mapping_predicates: Optional[List[str]] = None,
    propagate: bool = False,
) -> MappingSetDataFrame:
    """Parse an obographs file as a JSON object and translates it into a MappingSetDataFrame.

    :param file_path: The path to the obographs file
    :param prefix_map: an optional prefix map
    :param meta: an optional dictionary of metadata elements
    :param mapping_predicates: an optional list of mapping predicates that should be extracted
    :param propagate: If true, propagate all condensed slots.

    :returns: A SSSOM MappingSetDataFrame
    """
    raise_for_bad_path(file_path)

    converter, meta = _get_prefix_map_and_metadata(prefix_map=prefix_map, meta=meta)

    with open(file_path) as json_file:
        jsondoc = json.load(json_file)

    msdf = from_obographs(
        jsondoc,
        prefix_map=converter,
        meta=meta,
        mapping_predicates=mapping_predicates,
    )
    if propagate:
        msdf.propagate()
    return msdf

parse_alignment_xml(file_path, prefix_map=None, meta=None, mapping_predicates=None, propagate=False)

Parse a TSV -> MappingSetDocument -> MappingSetDataFrame.

Source code in src/sssom/parsers.py

def parse_alignment_xml(
    file_path: Union[str, Path],
    prefix_map: ConverterHint = None,
    meta: Optional[MetadataType] = None,
    mapping_predicates: Optional[List[str]] = None,
    propagate: bool = False,
) -> MappingSetDataFrame:
    """Parse a TSV -> MappingSetDocument -> MappingSetDataFrame."""
    raise_for_bad_path(file_path)

    converter, meta = _get_prefix_map_and_metadata(prefix_map=prefix_map, meta=meta)
    logging.info("Loading from alignment API")
    xmldoc = minidom.parse(Path(file_path).resolve().as_posix())
    msdf = from_alignment_minidom(
        xmldoc,
        prefix_map=converter,
        meta=meta,
        mapping_predicates=mapping_predicates,
    )
    if propagate:
        msdf.propagate()
    return msdf

from_sssom_dataframe(df, prefix_map=None, meta=None)

Convert a dataframe to a MappingSetDataFrame.

:param df: A mappings dataframe :param prefix_map: A prefix map :param meta: A metadata dictionary

:returns: MappingSetDataFrame

Source code in src/sssom/parsers.py

def from_sssom_dataframe(
    df: pd.DataFrame,
    prefix_map: ConverterHint = None,
    meta: Optional[MetadataType] = None,
) -> MappingSetDataFrame:
    """Convert a dataframe to a MappingSetDataFrame.

    :param df: A mappings dataframe
    :param prefix_map: A prefix map
    :param meta: A metadata dictionary

    :returns: MappingSetDataFrame
    """
    converter = ensure_converter(prefix_map)

    # Need to revisit this solution.
    # This is to address: A value is trying to be set on a copy of a slice from a DataFrame
    if CONFIDENCE in df.columns:
        df.replace({CONFIDENCE: r"^\s*$"}, np.nan, regex=True, inplace=True)

    mapping_set = _get_mapping_set_from_df(df=df, meta=meta)
    doc = MappingSetDocument(mapping_set=mapping_set, converter=converter)
    return to_mapping_set_dataframe(doc)

from_sssom_rdf(g, prefix_map=None, meta=None)

Convert an SSSOM RDF graph into a SSSOM data table.

:param g: the Graph (rdflib) :param prefix_map: A dictionary containing the prefix map, defaults to None :param meta: Potentially additional metadata, defaults to None

:returns: MappingSetDataFrame object

Source code in src/sssom/parsers.py

def from_sssom_rdf(
    g: Graph,
    prefix_map: ConverterHint = None,
    meta: Optional[MetadataType] = None,
) -> MappingSetDataFrame:
    """Convert an SSSOM RDF graph into a SSSOM data table.

    :param g: the Graph (rdflib)
    :param prefix_map: A dictionary containing the prefix map, defaults to None
    :param meta: Potentially additional metadata, defaults to None

    :returns: MappingSetDataFrame object
    """
    converter = ensure_converter(prefix_map)

    # The priority order for combining metadata is:
    #  1. Metadata appearing in the SSSOM document
    #  2. Metadata passed through ``meta`` to this function
    #  3. Default metadata

    # We prepare a default dictionary with (2) and (3), which will be
    # automatically combined with the metadata extracted from the RDF
    # graph by the RDF converter.
    combine_meta = dict(
        ChainMap(
            meta or {},
            get_default_metadata(),
        )
    )

    return MappingSetRDFConverter().msdf_from_rdf(g, curie_converter=converter, meta=combine_meta)

from_sssom_json(jsondoc, prefix_map=None, meta=None)

Load a mapping set dataframe from a JSON object.

:param jsondoc: JSON document :param prefix_map: Prefix map :param meta: metadata used to augment the metadata existing in the mapping set

:returns: MappingSetDataFrame object

Source code in src/sssom/parsers.py

def from_sssom_json(
    jsondoc: Union[str, dict[str, Any], TextIO],
    prefix_map: ConverterHint = None,
    meta: Optional[MetadataType] = None,
) -> MappingSetDataFrame:
    """Load a mapping set dataframe from a JSON object.

    :param jsondoc: JSON document
    :param prefix_map: Prefix map
    :param meta: metadata used to augment the metadata existing in the mapping set

    :returns: MappingSetDataFrame object
    """
    converter = ensure_converter(prefix_map)

    mapping_set = cast(MappingSet, JSONLoader().load(source=jsondoc, target_class=MappingSet))

    # The priority order for combining metadata is:
    #  1. Metadata appearing in the SSSOM document
    #  2. Metadata passed through ``meta`` to this function
    #  3. Default metadata

    # As the Metadata appearing in the SSSOM document is already parsed by LinkML
    # we only need to overwrite the metadata from 2 and 3 if it is not present
    combine_meta = dict(
        ChainMap(
            meta or {},
            get_default_metadata(),
        )
    )

    _set_metadata_in_mapping_set(mapping_set, metadata=combine_meta, overwrite=False)
    mapping_set_document = MappingSetDocument(mapping_set=mapping_set, converter=converter)
    return to_mapping_set_dataframe(mapping_set_document)

from_alignment_minidom(dom, prefix_map=None, meta=None, mapping_predicates=None)

Read a minidom Document object.

:param dom: XML (minidom) object :param prefix_map: A prefix map :param meta: Optional meta data :param mapping_predicates: Optional list of mapping predicates to extract

:returns: MappingSetDocument

:raises ValueError: for alignment format: xml element said, but not set to yes. Only XML is supported!

Source code in src/sssom/parsers.py

def from_alignment_minidom(
    dom: Document,
    prefix_map: ConverterHint = None,
    meta: Optional[MetadataType] = None,
    mapping_predicates: Optional[List[str]] = None,
) -> MappingSetDataFrame:
    """Read a minidom Document object.

    :param dom: XML (minidom) object
    :param prefix_map: A prefix map
    :param meta: Optional meta data
    :param mapping_predicates: Optional list of mapping predicates to extract

    :returns: MappingSetDocument

    :raises ValueError: for alignment format: xml element said, but not set to yes. Only XML is
        supported!
    """
    converter = ensure_converter(prefix_map)
    ms = _init_mapping_set(meta)
    mlist: List[Mapping] = []
    # bad_attrs = {}

    if not mapping_predicates:
        mapping_predicates = DEFAULT_MAPPING_PROPERTIES

    alignments = dom.getElementsByTagName("Alignment")
    for n in alignments:
        for e in n.childNodes:
            if e.nodeType == Node.ELEMENT_NODE:
                node_name = e.nodeName
                if node_name == "map":
                    cell = e.getElementsByTagName("Cell")
                    for c_node in cell:
                        mdict: Dict[str, Any] = _cell_element_values(
                            c_node, converter, mapping_predicates=mapping_predicates
                        )
                        _add_valid_mapping_to_list(mdict, mlist, flip_superclass_assertions=True)

                elif node_name == "xml":
                    if e.firstChild.nodeValue != "yes":  # type: ignore[union-attr]
                        raise ValueError(
                            "Alignment format: xml element said, but not set to yes. Only XML is supported!"
                        )
                elif node_name == "onto1":
                    ms[SUBJECT_SOURCE_ID] = e.firstChild.nodeValue  # type: ignore[union-attr]
                elif node_name == "onto2":
                    ms[OBJECT_SOURCE_ID] = e.firstChild.nodeValue  # type: ignore[union-attr]
                elif node_name == "uri1":
                    ms[SUBJECT_SOURCE] = e.firstChild.nodeValue  # type: ignore[union-attr]
                elif node_name == "uri2":
                    ms[OBJECT_SOURCE] = e.firstChild.nodeValue  # type: ignore[union-attr]

    ms.mappings = mlist
    mapping_set_document = MappingSetDocument(mapping_set=ms, converter=converter)
    return to_mapping_set_dataframe(mapping_set_document)

from_obographs(jsondoc, prefix_map=None, meta=None, mapping_predicates=None)

Convert a obographs json object to an SSSOM data frame.

:param jsondoc: The JSON object representing the ontology in obographs format :param prefix_map: The prefix map to be used :param meta: Any additional metadata that needs to be added to the resulting SSSOM data frame, defaults to None :param mapping_predicates: Optional list of mapping predicates to extract

:returns: An SSSOM data frame (MappingSetDataFrame)

:raises Exception: When there is no CURIE

Source code in src/sssom/parsers.py

def from_obographs(
    jsondoc: Dict[str, Any],
    prefix_map: ConverterHint = None,
    meta: Optional[MetadataType] = None,
    mapping_predicates: Optional[List[str]] = None,
) -> MappingSetDataFrame:
    """Convert a obographs json object to an SSSOM data frame.

    :param jsondoc: The JSON object representing the ontology in obographs format
    :param prefix_map: The prefix map to be used
    :param meta: Any additional metadata that needs to be added to the resulting SSSOM data frame,
        defaults to None
    :param mapping_predicates: Optional list of mapping predicates to extract

    :returns: An SSSOM data frame (MappingSetDataFrame)

    :raises Exception: When there is no CURIE
    """
    converter = ensure_converter(prefix_map)
    ms = _init_mapping_set(meta)
    mlist: List[Mapping] = []

    if not mapping_predicates:
        mapping_predicates = DEFAULT_MAPPING_PROPERTIES

    graphs = jsondoc.get("graphs")
    if not graphs:
        raise Exception("No graphs element in obographs file, wrong format?")

    #: A dictionary of node URIs to node labels
    labels: Mapping[str, str] = {
        node["id"]: node.get("lbl")
        for graph in graphs
        for node in graph.get("nodes", [])
        if node.get("lbl")
    }

    for graph in graphs:
        for node in graph.get("nodes", []):
            meta = node.get("meta")
            if not meta:
                continue

            node_uri = node["id"]
            if OBO_HAS_DB_XREF_URI in mapping_predicates:
                for xref in meta.get("xrefs", []):
                    mdict = _make_mdict(
                        node_uri, OBO_HAS_DB_XREF_URI, xref["val"], converter, labels
                    )
                    _add_valid_mapping_to_list(mdict, mlist)

            for value in meta.get("basicPropertyValues", []):
                predicate_uri = value["pred"]
                if predicate_uri not in mapping_predicates:
                    continue
                mdict = _make_mdict(node_uri, predicate_uri, value["val"], converter, labels)
                _add_valid_mapping_to_list(mdict, mlist)

        for edge in graph.get("edges", []):
            predicate_uri = _get_obographs_predicate_id(edge["pred"])
            if predicate_uri not in mapping_predicates:
                continue
            mdict = _make_mdict(edge["sub"], predicate_uri, edge["obj"], converter, labels)
            _add_valid_mapping_to_list(mdict, mlist)

        if OWL_EQUIV_CLASS_URI in mapping_predicates:
            for equivalents in graph.get("equivalentNodesSets", []):
                node_uris = equivalents.get("nodeIds")
                if not node_uris:
                    continue
                for subject_uri, object_uri in itt.product(node_uris, repeat=2):
                    if subject_uri == object_uri:
                        continue
                    mdict = _make_mdict(
                        subject_uri, OWL_EQUIV_CLASS_URI, object_uri, converter, labels
                    )
                    _add_valid_mapping_to_list(mdict, mlist)

    ms.mappings = mlist
    mdoc = MappingSetDocument(mapping_set=ms, converter=converter)
    return to_mapping_set_dataframe(mdoc)

get_parsing_function(input_format, filename)

Return appropriate parser function based on input format of file.

:param input_format: File format :param filename: Filename

:returns: Appropriate 'read' function

:raises ValueError: Unknown file format

Source code in src/sssom/parsers.py

def get_parsing_function(
    input_format: Optional[str], filename: str
) -> Callable[..., MappingSetDataFrame]:
    """Return appropriate parser function based on input format of file.

    :param input_format: File format
    :param filename: Filename

    :returns: Appropriate 'read' function

    :raises ValueError: Unknown file format
    """
    if input_format is None:
        input_format = get_file_extension(filename) or "tsv"
    func = PARSING_FUNCTIONS.get(input_format)
    if func is None:
        raise ValueError(f"Unknown input format: {input_format}")
    return func

to_mapping_set_document(msdf)

Convert a MappingSetDataFrame to a MappingSetDocument.

Source code in src/sssom/parsers.py

def to_mapping_set_document(msdf: MappingSetDataFrame) -> MappingSetDocument:
    """Convert a MappingSetDataFrame to a MappingSetDocument."""
    ms = _get_mapping_set_from_df(df=msdf.df, meta=msdf.metadata)
    return MappingSetDocument(mapping_set=ms, converter=msdf.converter)

split_dataframe(msdf, method=None)

Group the mapping set dataframe into several subdataframes by prefix.

:param msdf: MappingSetDataFrame object

:returns: Mapping object

:raises RuntimeError: DataFrame object within MappingSetDataFrame is None

Source code in src/sssom/parsers.py

def split_dataframe(
    msdf: MappingSetDataFrame,
    method: SplitMethod | None = None,
) -> Dict[str, MappingSetDataFrame]:
    """Group the mapping set dataframe into several subdataframes by prefix.

    :param msdf: MappingSetDataFrame object

    :returns: Mapping object

    :raises RuntimeError: DataFrame object within MappingSetDataFrame is None
    """
    subject_prefixes = set(msdf.df[SUBJECT_ID].str.split(":", n=1, expand=True)[0])
    object_prefixes = set(msdf.df[OBJECT_ID].str.split(":", n=1, expand=True)[0])
    relations = set(msdf.df[PREDICATE_ID])
    return split_dataframe_by_prefix(
        msdf=msdf,
        subject_prefixes=subject_prefixes,
        object_prefixes=object_prefixes,
        relations=relations,
        method=method,
    )

split_dataframe_by_prefix(msdf, subject_prefixes, object_prefixes, relations, *, method=None)

Split a mapping set dataframe by prefix.

:param msdf: An SSSOM MappingSetDataFrame :param subject_prefixes: a list of prefixes pertaining to the subject :param object_prefixes: a list of prefixes pertaining to the object :param relations: a list of relations of interest :param method: The method for calculating splits

:returns: a dict of SSSOM data frame names to MappingSetDataFrame

Source code in src/sssom/parsers.py

def split_dataframe_by_prefix(
    msdf: MappingSetDataFrame,
    subject_prefixes: Iterable[str],
    object_prefixes: Iterable[str],
    relations: Iterable[str],
    *,
    method: SplitMethod | None = None,
) -> Dict[str, MappingSetDataFrame]:
    """Split a mapping set dataframe by prefix.

    :param msdf: An SSSOM MappingSetDataFrame
    :param subject_prefixes: a list of prefixes pertaining to the subject
    :param object_prefixes: a list of prefixes pertaining to the object
    :param relations: a list of relations of interest
    :param method: The method for calculating splits

    :returns: a dict of SSSOM data frame names to MappingSetDataFrame
    """
    if method is None:
        return _split_dataframe_by_prefix_old(
            msdf,
            subject_prefixes=subject_prefixes,
            object_prefixes=object_prefixes,
            relations=relations,
        )

    predicates: List[ReferenceTuple] = []
    for relation in relations:
        if reference_tuple := msdf.converter.parse_curie(relation):
            predicates.append(reference_tuple)
        else:
            logging.warning("invalid relation CURIE for dataframe split: %s", relation)

    rr = _help_split_dataframe_by_prefix(
        msdf.df,
        subject_prefixes=subject_prefixes,
        predicates=predicates,
        object_prefixes=object_prefixes,
        method=method,
    )
    rv = {}
    for (subject_prefix, relation_t, object_prefix), df in rr:
        subconverter = msdf.converter.get_subconverter(
            [subject_prefix, object_prefix, relation_t.prefix]
        )
        split = _get_split_key(subject_prefix, relation_t.identifier, object_prefix)
        rv[split] = from_sssom_dataframe(df, prefix_map=subconverter, meta=msdf.metadata)
    return rv