def writeConfig(self): 
   log.info("Writing config...")
   trigs = {}
   for i in self.triggers:
     trigs[i.trigger] = i.text
   log.info("Saving : {}".format(trigs))
   settings = {
               "bot": {
                 "name": self.botname,
                 "version": self.bot_version,
                 "msg_prefix": self.bot_prefix,
                 "cmd_prefix": self.cmd_prefix,
                 "debug_logging": False 
               },
               "modules": {
                 "path": self.path,
                 "load": self.init_modules
               },
               "triggers": trigs,
               "admins": self.admins,
               "ai":{"model_directory":"models"}
             }
   log.info(pyaml.dump(settings))
   with open("discord-config.conf", "w") as f:
     f.write(pyaml.dump(settings))
   log.info("Written") 

    def do_list(self):
        """
        Usage: list
        """
        archives = self.cache._for_adf('archives')

        if len(archives):
            for n, archive in enumerate(archives.iteritems()):
                archive = archive[1]
                status = "LOCAL"
                cert = ""
                if 'signature' in archive:
                    status = "COMPLETE"
                    cert = archive['signature'].aid
                elif 'links' in archive and archive['links'].upload:
                    status = "UPLOADED"
                    if self.verbose:
                        cert = archive['links'].upload
                title = archive['archive'].title
                size = archive_size(archive['archive'])
                print "{:03d} {:>6} {:>20} {:>10} {:>10}".format(
                    n+1, size, title, status, cert)
                if self.debug > 2:
                    for doc in archive.itervalues():
                        pyaml.dump(doc, sys.stdout)
                    print
        else:
            print "No available archives."

 def write_settings_file(self, eps_values):
     eps_values['min_samples'] = self.min_samples
     eps_values['only_core_samples'] = self.only_core_samples
     settingspath = self.pm.blotchfile.parent / 'clustering_settings.yaml'
     settingspath.parent.mkdir(exist_ok=True, parents=True)
     logger.info("Writing settings file at %s", str(settingspath))
     with open(settingspath, 'w') as fp:
         pyaml.dump(eps_values, fp)

	def test_str_style_pick(self):
		a = pyaml.dump(data_str_multiline)
		b = pyaml.dump(data_str_multiline, string_val_style='|')
		self.assertEqual(a, b)
		b = pyaml.dump(data_str_multiline, string_val_style='plain')
		self.assertNotEqual(a, b)
		self.assertTrue(pyaml.dump('waka waka', string_val_style='|').startswith('|-\n'))
		self.assertEqual(pyaml.dump(dict(a=1), string_val_style='|'), 'a: 1\n')

def type_diff(a, b):
    s = StringIO.StringIO()
    pyaml.dump(a, s, safe = True)
    a = s.getvalue().splitlines()
    s = StringIO.StringIO()
    pyaml.dump(b, s, safe = True)
    b = s.getvalue().splitlines()
    return '\n'.join(difflib.Differ().compare(a, b))

 def test_str_style_pick(self):
     a = pyaml.dump(data_str_multiline)
     b = pyaml.dump(data_str_multiline, string_val_style="|")
     self.assertEqual(a, b)
     b = pyaml.dump(data_str_multiline, string_val_style="plain")
     self.assertNotEqual(a, b)
     self.assertTrue(pyaml.dump("waka waka", string_val_style="|").startswith("|-\n"))
     self.assertEqual(pyaml.dump(dict(a=1), string_val_style="|"), "a: 1\n")

	def test_colons_in_strings(self):
		val1 = {'foo': ['bar:', 'baz', 'bar:bazzo', 'a: b'], 'foo:': 'yak:'}
		val1_str = pyaml.dump(val1)
		val2 = yaml.safe_load(val1_str)
		val2_str = pyaml.dump(val2)
		val3 = yaml.safe_load(val2_str)
		self.assertEqual(val1, val2)
		self.assertEqual(val1_str, val2_str)
		self.assertEqual(val2, val3)

 def test_colons_in_strings(self):
     val1 = {"foo": ["bar:", "baz", "bar:bazzo", "a: b"], "foo:": "yak:"}
     val1_str = pyaml.dump(val1)
     val2 = yaml.safe_load(val1_str)
     val2_str = pyaml.dump(val2)
     val3 = yaml.safe_load(val2_str)
     self.assertEqual(val1, val2)
     self.assertEqual(val1_str, val2_str)
     self.assertEqual(val2, val3)

 def test_empty_strings(self):
     val1 = {"key": ["", "stuff", "", "more"], "": "value", "k3": ""}
     val1_str = pyaml.dump(val1)
     val2 = yaml.safe_load(val1_str)
     val2_str = pyaml.dump(val2)
     val3 = yaml.safe_load(val2_str)
     self.assertEqual(val1, val2)
     self.assertEqual(val1_str, val2_str)
     self.assertEqual(val2, val3)

    def dump(self, data, path):
        """dump data to file
        """

        with open(path, "w") as f:

            if isinstance(data, MergeableDict):
                pyaml.dump(data.convert_to(data), f)
            else:
                pyaml.dump(data, f)

    def dump(self, content, filepath, indent=4):
        """
        Dump settings content to filepath.

        Args:
            content (str): Settings content.
            filepath (str): Settings file location.
        """
        with open(filepath, 'w') as fp:
            pyaml.dump(content, dst=fp, indent=indent)

def main(argv=None):
	import argparse
	parser = argparse.ArgumentParser(
		description='Process and dump prettified YAML to stdout.')
	parser.add_argument('path', nargs='?', metavar='path',
		help='Path to YAML to read (default: use stdin).')
	opts = parser.parse_args(argv or sys.argv[1:])

	src = open(opts.path) if opts.path else sys.stdin
	try: data = yaml.load(src)
	finally: src.close()

	pyaml.dump(data, sys.stdout)

    def do_list(self):
        """
        Usage: list
        """
        archives = list(self.cache._for_adf('archives').iteritems())

        if len(archives):
            ui.print_archives_header()
            bydate = sorted(archives,
                            key=compose(creation, operator.itemgetter(1)))
            for n, docs in enumerate(bydate):
                fname = docs[0]
                archive = docs[1]
                status = self.cache.archive_status(fname, archive)
                cert = ""
                if status == ArchiveStatus.Completed:
                    status = "COMPLETE"
                    cert = archive['signature'].aid
                elif status == ArchiveStatus.InProgress:
                    status = "IN PROGRESS"
                    if self.verbose:
                        cert = archive['links'].upload
                elif status == ArchiveStatus.Failed:
                    status = "FAILED"
                    if self.verbose:
                        cert = archive['links'].upload
                elif status == ArchiveStatus.Local:
                    status = "LOCAL"
                elif status == ArchiveStatus.Paused:
                    status = "PAUSED"
                else:
                    status = "UNKNOWN"
                title = archive['archive'].title
                size = archive_size(archive['archive'])

                ui.print_archives_line(archive={
                    'num': n+1,
                    'size': size,
                    'title': title,
                    'status': status,
                    'cert': cert,
                    'created': archive['archive'].meta.created,
                    'capsule': archive_capsule(archive) or '-'
                })
                if self.debug > 2:
                    for doc in archive.itervalues():
                        pyaml.dump(doc, sys.stdout)
                    print
            print
        else:
            print "No available archives."

	def test_multiple_docs(self):
		docs = [yaml.safe_load(large_yaml), dict(a=1, b=2, c=3)]
		docs_str = pyaml.dump_all(docs, vspacing=[3, 2])
		self.assertTrue(docs_str.startswith('---'))
		self.assertIn('---\n\n\n\na: 1\n\n\n\nb: 2\n\n\n\nc: 3\n', docs_str)
		docs_str2 = pyaml.dump(docs, vspacing=[3, 2], multiple_docs=True)
		self.assertEqual(docs_str, docs_str2)
		docs_str2 = pyaml.dump(docs, vspacing=[3, 2])
		self.assertNotEqual(docs_str, docs_str2)
		docs_str2 = pyaml.dump_all(docs, explicit_start=False)
		self.assertFalse(docs_str2.startswith('---'))
		self.assertNotEqual(docs_str, docs_str2)
		docs_str = pyaml.dump(docs, multiple_docs=True, explicit_start=False)
		self.assertEqual(docs_str, docs_str2)

	def test_print(self):
		self.assertIs(pyaml.print, pyaml.pprint)
		self.assertIs(pyaml.print, pyaml.p)
		buff = io.BytesIO()
		b = pyaml.dump(data_str_multiline, dst=bytes)
		pyaml.print(data_str_multiline, file=buff)
		self.assertEqual(b, buff.getvalue())

def write():  # pragma: no cover
    global _cache
    yfn = yaml_file_name()
    touch(yfn)
    with open(yfn, "w") as outfile:
        outfile.write(dump(_cache, vspacing=[1, 0]))
    return None

	def test_pyyaml_params(self):
		d = {'foo': 'lorem ipsum ' * 30} # 300+ chars
		for w in 40, 80, 200:
			lines = pyaml.dump(d, width=w, indent=10).splitlines()
			for n, line in enumerate(lines, 1):
				self.assertLess(len(line), w*1.2)
				if n != len(lines): self.assertGreater(len(line), w*0.8)

 def to_yaml(self):
     """overwrite default DeclarativeBase.to_yaml method because we need to convert MutableDicts first
     """
     node_dict = self.to_dict()
     node_dict["attrs"] = dict(node_dict["attrs"])
     node_dict["system_attrs"] = dict(node_dict["system_attrs"])
     return pyaml.dump(node_dict)

  def writeConfig(self):
    """Save the config, all currently loaded modules will be saved to init_modules"""
    self.log.info("Writing config...")

    #Add all of our triggers to a nice little dictionary,
    #So we can write it to a file
    trigs = {}
    for i in self.triggers:
      trigs[i.trigger] = i.send_text

    settings = {
        "bot" : {
          "name": self.bot_name,
          "version": self.bot_version,
          "msg_prefix": self.msg_prefix,
          "cmd_prefix": self.command_prefix,
          "debug_logging": False
        },
        "modules" : {
          "path": self.module_path,
          "load": self.loadedModules
        },
        "triggers": trigs,
        "ai": {
          "model_directory": "models"
        },
        "admins": self.admins
      } 

    self.log.info(settings)
    
    #Write the config in YAML format 
    with open("command-proc.conf", "w") as f:
      f.write(pyaml.dump(settings))
    self.log.info("Written")

 def write(self):
     d = self._serialize()
     s = pyaml.dump(d)
     p = os.path.dirname(self.filename)
     if not os.path.exists(p):
         os.makedirs(p)
     with open(self.filename, 'w') as f:
         f.write(s)
     self._reset_changes()