docs: def write(self, fmt='turtle', stream=None):
          """
          This convenience method will write out all of the graphs
          associated with the source.
          Right now these are hardcoded to be a single "graph"
          and a "src_dataset.ttl" and a "src_test.ttl"
          If you do not supply stream='stdout'
          it will default write these to files.
  
          In addition, if the version number isn't yet set in the dataset,
          it will be set to the date on file.
          :return: None
  
          """
          fmt_ext = {
              'rdfxml': 'xml',
              'turtle': 'ttl',
              'nt': 'nt',         # ntriples
              'nquads':  'nq',
              'n3': 'n3'          # notation3
          }
  
          # make the regular graph output file
          dest = None
          if self.name is not None:
              dest = '/'.join((self.outdir, self.name))
              if fmt in fmt_ext:
                  dest = '.'.join((dest, fmt_ext.get(fmt)))
              else:
                  dest = '.'.join((dest, fmt))
              LOG.info("Setting outfile to %s", dest)
  
              # make the dataset_file name, always format as turtle
              self.datasetfile = '/'.join(
                  (self.outdir, self.name + '_dataset.ttl'))
              LOG.info("Setting dataset file to %s", self.datasetfile)
  
              if self.dataset is not None and self.dataset.version is None:
                  self.dataset.set_version_by_date()
                  LOG.info("No version for %s setting to date issued.", self.name)
          else:
              LOG.warning("No output file set. Using stdout")
              stream = 'stdout'
  
          gu = GraphUtils(None)
  
          # the  _dataset description is always turtle
          gu.write(self.dataset.getGraph(), 'turtle', filename=self.datasetfile)
  
          if self.test_mode:
              # unless we stop hardcoding, the test dataset is always turtle
              LOG.info("Setting testfile to %s", self.testfile)
              gu.write(self.testgraph, 'turtle', filename=self.testfile)
  
          # print graph out
          if stream is None:
              outfile = dest
          elif stream.lower().strip() == 'stdout':
              outfile = None
          else:
              LOG.error("I don't understand our stream.")
              return
          gu.write(self.graph, fmt, filename=outfile)