def testBuggyNodesReduce(self):
     object = syck.load(BUGGY_NODES)
     nodes = syck.parse(BUGGY_NODES)
     output = syck.dump(nodes)
     #print output
     nodes2 = syck.load(output)
     output2 = syck.emit(nodes2)
     object2 = syck.load(output2)
     self.assertEqual(object, object2)

 def testExtensions(self):
     source = EXTENSIONS[0]
     object = EXTENSIONS[1]
     object2 = syck.load(source, Loader=ExLoader)
     for left, right in zip(object, object2):
         self.assertEqual(left, right)
     source2 = syck.dump(object2, Dumper=ExDumper)
     object3 = syck.load(source2, Loader=ExLoader)
     for left, right in zip(object, object3):
         self.assertEqual(left, right)

 def __init__(self, pref_string):
     # Load default values first
     from mallet.config import data_dir
     default_pref = open(os.path.join(data_dir, 'default.yaml')).read()
     default_data = syck.load(default_pref)
     # Load from user preferences
     self._data = syck.load(pref_string)
     if self._data is None:
         self._data = {}
     self._data.update(default_data)

 def testNonsense(self):
     class MyFile1:
         def read(self, max_length):
             return ' '*(max_length+1)
     class MyFile2:
         def read(self, max_length):
             return None
     self.assertRaises(ValueError, lambda: syck.parse(MyFile1()))
     self.assertRaises(ValueError, lambda: syck.load(MyFile1()))
     self.assertRaises(TypeError, lambda: syck.parse(MyFile2()))
     self.assertRaises(TypeError, lambda: syck.load(MyFile2()))

 def testTimestamp(self):
     # Again, Syck does not understand the latest two forms.
     #self.assertEqual(syck.load(
     #        '- 2001-12-15T02:59:43.1Z\n'
     #        '- 2001-12-14t21:59:43.10-05:00\n'
     #        '- 2001-12-14 21:59:43.10 -5\n'
     #        '- 2001-12-15 2:59:43.10\n'),
     #    [datetime.datetime(2001, 12, 15, 2, 59, 43, 100000)]*4)
     self.assertEqual(syck.load(
             '- 2001-12-15T02:59:43.1Z\n'
             '- 2001-12-14t21:59:43.10-05:00\n'
             '- 2001-12-14 21:59:43.10 -05\n'
             '- 2001-12-15 02:59:43.10 Z\n'),
         [datetime.datetime(2001, 12, 15, 2, 59, 43, 100000)]*4)
     self.assertEqual(syck.load('2002-12-14'), datetime.datetime(2002, 12, 14))

 def testLoad(self):
     self._testWarning()
     document, values = DOCUMENT
     new_values = syck.load(document)
     for string, new_string in zip(values, new_values):
         self.assertEqual(string, new_string)
         self.assertEqual(type(string), type(new_string))

    def prepare_data(self, fast = False):
        Diagnostic.prepare_data(self, fast)

        from path import path

        logdir = path(self.logfilename).parent
        daigpath = logdir/'diag.yaml'

        if daigpath.isfile():
            with open(daigpath, 'r') as diagfile:
                data = syck.load(diagfile)

            # ensure that the process that crashed was the one that wrote the file
            uniquekey = getattr(getattr(sys, 'opts', None), 'crashuniquekey', None)
            if uniquekey is None:
                return

            try:
                uniquekey = int(uniquekey)
            except ValueError:
                uniquekey = None

            if data['uniquekey'] != uniquekey:
                return

            crun = data['args']['crun']
            if self.crashuser is not None and crun != self.crashuser:
                msg = 'ERROR: crash user does not match: %r and %r' % (self.crashuser, crun)
                print >> sys.stderr, msg
                return # don't update with YAML data

            self.prepared_args.update(data['args'])
            self.prepared_files.update(data['files'])

    def got_updateyaml(self, req = None, fobj = None):
        '''
        an open fileobject that contains yaml with manifest locations in it.
        '''
        try:
            data = fobj.read()
        except Exception as e:
            return self.manifest_path_error(e)

        try:
            ui = syck.load(data)
        except Exception as e:
            return self.manifest_path_error(e)

        all = ui.get('all', {})
        mine = ui.get(config.platform, None) or {}

        merged = all.copy()
        merged.update(mine)

        manifest_path = merged.get(self.release_type, merged.get('release', None))
        if manifest_path is None:
            self.update_check_error(Exception("No manifest URL for %r in %r" % (self.release_type, all)))
        else:
            log.info("Got manifest path: %r", manifest_path)
            self.remote_manifest_path = manifest_path
            downloader.httpopen(self.remote_manifest_path, method = 'HEAD', success = self.check_manifest_integrity, error = self.manifest_check_error)

 def testMutableKey(self):
     document = syck.load(MUTABLE_KEY)
     self.assertEqual(type(document), list)
     self.assertEqual(len(document), 1)
     self.assertEqual(type(document[0]), tuple)
     self.assertEqual(len(document[0]), 2)
     self.assertEqual(document[0][0], document[0][1])

 def testDuplicateKey(self):
     document = syck.load(DUPLICATE_KEY)
     self.assertEqual(type(document), list)
     self.assertEqual(len(document), 2)
     self.assertEqual(len(document[0]), 2)
     self.assertEqual(len(document[1]), 2)
     self.assertEqual(document[0][0], document[1][0])

 def yaml(self):
     if self._yaml is None and has_yaml:
         try:
             self._yaml = yaml.load(self.data)
         except yaml_error:
             pass
     return self._yaml

def yaml_load(filename):
    """Load and interpret a YAML file, using whichever library is
    found. The following packages are tried:

     pysyck
     pyyaml (with C extensions if available)

    """
    f = open(filename)
    try:
        import syck
        s = f.read()
        y = syck.load(s)

    except:
        import yaml
        try:
            from yaml import CLoader as Loader
        except ImportError:
            from yaml import Loader

        y = yaml.load(f, Loader=Loader)

    f.close()
    return y

    def __init__(self, lang_override=None):

        # L_O_G.info('init spellchecker')

        self.spellengine = None
        self.lang = None
        self._need_to_download = None
        self.currentDownloads = set()
        self.expectedNext = None

        # load YAML file describing the dictionaries

        filename = program_dir() / "res" / ("dictionaries-%s.yaml" % Aspell.VERSION)
        try:
            with open(filename) as f:
                self.dict_info = syck.load(f)
                if not isinstance(self.dict_info, dict):
                    raise ValueError("invalid YAML in %s" % filename)
        except Exception:
            print_exc()
            self.dict_info = {}

        # load an engine using swap engine, if no engine is failed use the NullSpellEngine
        if not self.SwapEngine(lang_override):
            self.spellengine = NullSpellEngine()

        profile.prefs.add_observer(
            self.on_prefs_change,  # @UndefinedVariable
            "messaging.spellcheck.enabled",
            "messaging.spellcheck.engineoptions.lang",
            "messaging.spellcheck.engineoptions.encoding",
            "messaging.spellcheck.engineoptions.keyboard",
            "messaging.spellcheck.engineoptions.sug-mode",
        )  # @UndefinedVariable

def load_soundset(name):
    set_name = set_dir = None

    for set_name, set_dir in list_soundsets():
        if set_name == name:
            found = True
            break
    else:
        found = False

    if set_dir and found:
        soundset_yaml = set_dir / DESC_FILENAME
    else:
        soundset_yaml = None

    if soundset_yaml is None or not soundset_yaml.isfile():
        raise SoundsetException('soundset %r is missing %r' % (name, DESC_FILENAME))

    # load from YAML file in res dir
    with file(soundset_yaml, 'r') as f:
        soundset = syck.load(f)

    if soundset is None:
        raise SoundsetException('soundset %r is empty' % name)

    # fix contact_signoff -> contact.signoff
    underscores_to_dots(soundset)

    # turn relative paths in YAML to actual paths
    fix_paths(soundset, set_dir)

    return Soundset(soundset)

    def updatesite(self):
        if self._updatesite is None:
            try:
                self._updatesite = syck.load((self.local_path / 'index.yaml').open())['source']
            except Exception:
                raise Exception('Unknown source site for %r', self)

        return self._updatesite

 def testScalarTypes(self):
     scalars = syck.load(syck.dump(SCALARS))
     for a, b in zip(scalars, SCALARS):
         self.assertEqual(type(a), type(b))
         if type(a) is float:
             self.assertEqual(repr(a), repr(b))
         else:
             self.assertEqual(a, b)

 def yaml(self):
     """ The probe data as a decoded YAML data structure """
     if self._yaml is None and HAS_YAML:
         try:
             self._yaml = yaml.load(self.data)
         except YAMLError:
             pass
     return self._yaml

def wkstats():
    '''Returns a dictionary of WebKit memory statistics.'''

    from cStringIO import StringIO
    import wx.webview
    import syck

    return syck.load(StringIO(wx.webview.WebView.GetStatistics().encode('utf-8')))

 def testInteger(self):
     # Syck does not understand '_' and binary integer.
     #self.assertEqual(syck.load(
     #    '- 685230\n- +685_230\n- 02472256\n- 0x_0A_74_AE\n'
     #    '- 0b1010_0111_0100_1010_1110\n- 190:20:30\n'), [685230]*6)
     self.assertEqual(syck.load(
         '- 685230\n- +685230\n- 02472256\n- 0x0A74AE\n'
         '- 190:20:30\n'), [685230]*5)

    def LoadKeys(self, filepath):
        'Loads a set of keyboard shortcuts from a YAML file.'

        addkey = self.AddKeyboardShortcut
        import syck

        with open(filepath) as f:
            for actionname, accels in flatten(merge_keys(syck.load(f))):
                addkey(actionname, accels)