How to use the rdflib.graph function in rdflib

function sparqlUpdate (filename, targetURI, text, callback) {
  var patchURI = targetURI // @@@ beware the triples from the patch ending up in the same place
  var patchKB = $rdf.graph()
  var targetKB = $rdf.graph()
  var targetContentType = mime.lookup(filename)

  debug('PATCH -- parsing patch ...')
  var patchObject
  try {
    // Must parse relative to document's base address but patch doc should get diff URI
    patchObject = $rdf.sparqlUpdateParser(text, patchKB, patchURI)
  } catch (e) {
    return callback(error(400, 'Patch format syntax error:\n' + e + '\n'))
  }
  debug('PATCH -- reading target file ...')

  waterfall([
    (cb) => {
      fs.stat(filename, (err) => {
        if (!err) return cb()

async listContainer (filename, reqUri, containerData, hostname) {
    const resourceGraph = $rdf.graph()

    try {
      $rdf.parse(containerData, resourceGraph, reqUri, 'text/turtle')
    } catch (err) {
      debug.handlers('GET -- Error parsing data: ' + err)
      throw error(500, "Can't parse container")
    }

    try {
      // add container stats
      await ldpContainer.addContainerStats(this, reqUri, filename, resourceGraph)
      // read directory
      const files = await ldpContainer.readdir(filename)
      // iterate through all the files
      await Promise.all(files.map(async file => {
        const { url: fileUri } = await this.resourceMapper.mapFileToUrl(

function sparqlUpdate (filename, targetURI, text, callback) {
  var patchURI = targetURI // @@@ beware the triples from the patch ending up in the same place
  var patchKB = $rdf.graph()
  var targetKB = $rdf.graph()
  var targetContentType = mime.lookup(filename)

  debug('PATCH -- parsing patch ...')
  var patchObject
  try {
    // Must parse relative to document's base address but patch doc should get diff URI
    patchObject = $rdf.sparqlUpdateParser(text, patchKB, patchURI)
  } catch (e) {
    return callback(error(400, 'Patch format syntax error:\n' + e + '\n'))
  }
  debug('PATCH -- reading target file ...')

  waterfall([
    (cb) => {
      fs.stat(filename, (err) => {

function chargeLRS(id, obj, store) {
  const lrs = new LinkedRenderStore({ store: rdf.graph() });
  lrs.store.add(obj);
  return context(exNS(id), lrs, store);
}

return new Promise((resolve, reject) => {
    const patchGraph = $rdf.graph()
    $rdf.parse(patchText, patchGraph, patchURI, 'text/n3')
    resolve(patchGraph)
  })
  .catch(err => { throw error(400, `Patch document syntax error: ${err}`) })

SHACLValidator.prototype.parseShapesGraph = function(text, mediaType, andThen) {
    var handleError = function (ex) {
        error(ex);
    };
    this.shapesStore = $rdf.graph();
    var that = this;
    rdflibgraph.loadGraph(text, this.shapesStore, shapesGraphURI, mediaType, function () {
        rdflibgraph.loadGraph(shaclFile, that.shapesStore, "http://shacl.org", "text/turtle", function () {
            rdflibgraph.loadGraph(dashFile, that.shapesStore, "http://datashapes.org/dash", "text/turtle", function () {
                that.$shapes = new RDFLibGraph(that.shapesStore);
                andThen();
            });
        }, handleError);
    }, handleError);
};

writeTriples(uri, tripsToWrite) {
    const toAdd = $rdf.graph()
    return this.fetchTriplesAtUri(uri).then(fetchedTrips => {
      const writer = new Writer()
      writer.addAll(fetchedTrips.triples)
      tripsToWrite.forEach(t => {
        if (writer.find(t.subject, t.predicate, t.object).length === 0) {
          toAdd.add(t.subject, t.predicate, t.object)
        }
      })
    }).then(() => {
      return this.patch(this._proxify(uri), [], toAdd.statements)
    })
  }

.on('end', function () {
        const graph = $rdf.graph()
        $rdf.parse(data, graph, baseUri, from, function (err) {
          if (err) return reject(err)
          resolve(serialize(graph, baseUri, to))
        })
      })
  })

return this.ldp.fetchTriplesAtUri(seeAlso).then(rdfData => {
      if (rdfData.unav) {
        return
      }

      const extG = rdf.graph()
      extG.addAll(rdfData.triples)

      let value
      if (key === 'idCardFields' || key === 'passportFields') {
        value = this._formatIdCardInfo(extG)
      } else {
        value = extG.statementsMatching(undefined, pred, undefined)[0]
          .object.value
      }
      return {id, verified: false, [key]: value}
    })
  }