def METHOD_NAME(
    self,
    filename: str,
    format: str = "owl",
    compression: Optional[str] = None,
    **kwargs: Any,
) -> typing.Generator:
    """
    This method reads from an OWL and yields records.
    Parameters
    ----------
    filename: str
        The filename to parse
    format: str
        The format (``owl``)
    compression: Optional[str]
        The compression type (``gz``)
    kwargs: Any
        Any additional arguments
    Returns
    -------
    Generator
        A generator for node and edge records read from the file
    """
    rdfgraph = rdflib.Graph()
    if compression:
        log.warning(f"compression mode '{compression}' not supported by OwlSource")
    if format is None:
        format = rdflib.util.guess_format(filename)
    if format == "owl":
        format = "xml"
    log.info("Parsing {} with '{}' format".format(filename, format))
    rdfgraph.METHOD_NAME(filename, format=format)
    log.info("{} parsed with {} triples".format(filename, len(rdfgraph)))
    self.set_provenance_map(kwargs)
    self.start = current_time_in_millis()
    log.info(f"Done parsing {filename}")
    triples = rdfgraph.triples((None, OWL.imports, None))
    for s, p, o in triples:
        # Load all imports first
        if p == OWL.imports:
            if o not in self.imported:
                input_format = rdflib.util.guess_format(o)
                imported_rdfgraph = rdflib.Graph()
                log.info(f"Parsing OWL import: {o}")
                self.imported.add(o)
                imported_rdfgraph.METHOD_NAME(o, format=input_format)
                self.load_graph(imported_rdfgraph)
            else:
                log.warning(f"Trying to import {o} but its already done")
    yield from self.load_graph(rdfgraph)