#!/usr/bin/env python

from __future__ import print_function

import os

import re

import sys

# == globals

printDebug = False

try:

unicode

except NameError:

unicode = str

# ==

class yamlValue(unicode):

linenumber = None

def __new__(cls, value, linenumber=None):

if isinstance(value, unicode):

real = unicode.__new__(cls, value)

else:

real = unicode.__new__(cls, value, "utf-8")

if linenumber is not None:

real.linenumber = int(linenumber)

return real

def __repr__(self):

real = super(yamlValue, self).__repr__()

return real.lstrip("u")

def parseYAML(source):

def debug(message):

if printDebug and message:

message = str(message).rstrip()

if message:

print(message)

sys.stdout.flush()

commentLineRegex = re.compile("^\s*#")

yamlLineRegex = re.compile(

"^(?P<indent> *)((?P<itemMarker>- +)(?P<itemContent>.*)|((?P<key>[\w\.]+)(?P<keyExtra>: *))?(?P<content>.*))\s*$"

)

def parseYAML_inner(source, indent):

returnItem = None

for linenumber, line in source:

if line == "": # no newline, so EOF

break

debug("line %d (%d):%s" % (linenumber, indent, line))

if line.strip() == "" or commentLineRegex.match(

line

): # empty or comment line, ignore

debug("\tempty/comment line")

continue

# - parse line

parsedLine = yamlLineRegex.match(line)

if not parsedLine:

raise Exception(

"Unparseable YAML line %d: %s" % (linenumber, line.rstrip())

)

lineIndent = len(parsedLine.group("indent"))

lineItemMarker = parsedLine.group("itemMarker")

lineKey = parsedLine.group("key") or ""

lineKeyExtra = parsedLine.group("keyExtra") or ""

lineContent = (

parsedLine.group("content") or parsedLine.group("itemContent") or ""

).strip()

# - handle end-of-sections

if lineIndent < indent:

# we have dropped out of this item, push back the line and return what we have

source.send((linenumber, line))

debug("\tout one level")

return returnItem

# - array item

if lineItemMarker:

debug("\tarray item")

# item in an array

if returnItem is None:

debug("\tnew array, indent is %d" % lineIndent)

returnItem = []

indent = lineIndent

elif not isinstance(returnItem, list):

raise Exception(

"Bad YAML, got a list item while working on a %s on line %d: %s"

% (returnItem.__class__.__name__, linenumber, line.rstrip())

)

indentLevel = lineIndent + len(lineItemMarker)

source.send((linenumber, (" " * (indentLevel)) + lineContent))

returnItem += [parseYAML_inner(source=source, indent=indent + 1)]

# - dict item

elif lineKey:

debug("\tdict item")

if returnItem is None:

debug("\tnew dict, indent is %d" % lineIndent)

# new dict

returnItem = {}

indent = lineIndent

elif not isinstance(returnItem, dict):

raise Exception(

"Bad YAML, got a dict value while working on a %s on line %d: %s"

% (returnItem.__class__.__name__, linenumber, line.rstrip())

)

indentLevel = lineIndent + len(lineKey) + len(lineKeyExtra)

source.send((linenumber, (" " * indentLevel) + lineContent))

returnItem[lineKey] = parseYAML_inner(source=source, indent=indent + 1)

# - data - one or more lines of text

else:

debug("\tvalue")

if returnItem is None:

returnItem = yamlValue("", linenumber)

if lineContent.strip() in ("|", "|-", ">"):

continue # yaml multiline marker

elif not isinstance(returnItem, yamlValue):

raise Exception(

"Bad YAML, got a value while working on a %s on line %d: %s"

% (returnItem.__class__.__name__, linenumber, line.rstrip())

)

if returnItem:

returnItem = yamlValue(

returnItem + "\n" + lineContent, returnItem.linenumber

) # str subclasses are not fun

else:

returnItem = yamlValue(lineContent, linenumber)

return returnItem

def parseYAML_generator(source):

if hasattr(source, "capitalize"):

if os.path.isfile(source):

source = open(source, "r")

else:

source = source.splitlines(True)

elif hasattr(source, "readlines"):

pass # the for loop will already work

backlines = []

for linenumber, line in enumerate(source):

backline = None

usedLine = False

while usedLine is False or backlines:

if backlines:

backline = yield backlines.pop()

else:

usedLine = True

backline = yield (linenumber + 1, line)

while backline: # loops returning None for every send()

assert isinstance(backline, tuple)

assert isinstance(backline[0], int)

backlines.append(backline)

backline = yield None

return parseYAML_inner(parseYAML_generator(source), indent=0)

if __name__ == "__main__":

import optparse, pprint

parser = optparse.OptionParser()

parser.add_option(

"-d",

"--debug",

dest="debug",

action="store_true",

default=False,

help="print debug information",

)

(options, args) = parser.parse_args()

printDebug = options.debug

if len(args) < 1:

parser.error("%s needs files to process" % os.path.basename(__file__))

for filePath in args:

if not os.path.isfile(filePath):

sys.exit("target is not an existing file: %s" % os.path.basename(__file__))

for filePath in args:

print("=== %s" % filePath)

pprint.pprint(parseYAML(filePath))