parcon
index
/home/boydam/workspace/Parcon-python/parcon/parcon/__init__.py

parcon.py
 
Parcon is a parser combinator library written by Alexander Boyd. (His email
address is alex at open groove dot org, with no space in between "open" and
"groove".)
 
Technically, it's a monadic parser combinator library, but you don't need to
know that unless you're doing really fancy things. (The bind and return
operations are provided by the Bind and Return parsers, respectively.)
 
To get started, look at all of the subclasses of the Parser class, and
specifically, look at Parser's parse_string method. And perhaps try
running this:
 
parser = "(" + ZeroOrMore(SignificantLiteral("a") + SignificantLiteral("b")) + ")"
print parser.parse_string("(abbaabaab)")
print parser.parse_string("(a)")
print parser.parse_string("") # should raise an exception
print parser.parse_string("(a") # should raise an exception
print parser.parse_string("(ababacababa)") # should raise an exception
 
The Parser class, and hence all of its subclasses, overload a few operators
that can be used to make writing parsers easier. Here's what each operator
ends up translating to:
 
x + y is the same as Then(x, y).
x | y is the same as First(x, y).
x - y is the same as Except(x, y).
x & y is the same as And(x, y).
-x is the same as Optional(x).
+x is the same as OneOrMore(x).
~x is the same as Discard(x).
x[min:max] is the same as Repeat(x, min, max).
x[some_int] is the same as Repeat(x, some_int, some_int).
x[...] (three literal dots) is the same as ZeroOrMore(x).
x[function] is the same as Translate(x, function).
"x" op some_parser or some_parser op "x" is the same as Literal("x") op 
       some_parser or some_parser op Literal("x"), respectively.
 
A simple expression evaluator written using Parcon:
 
from parcon import *
from decimal import Decimal
import operator
expr = Forward()
number = (+Digit() + -(SignificantLiteral(".") + +Digit()))[flatten]["".join][Decimal]
term = number | "(" + expr + ")"
term = InfixExpr(term, [("*", operator.mul), ("/", operator.truediv)])
term = InfixExpr(term, [("+", operator.add), ("-", operator.sub)])
expr << term
 
Some example expressions that can now be evaluated using the above
simple expression evaluator:
 
print expr.parse_string("1+2") # prints 3
print expr.parse_string("1+2+3") # prints 6
print expr.parse_string("1+2+3+4") # prints 10
print expr.parse_string("3*4") # prints 12
print expr.parse_string("5+3*4") # prints 17
print expr.parse_string("(5+3)*4") # prints 32
print expr.parse_string("10/4") # prints 2.5
 
Another example use of Parcon, this one being a JSON parser (essentially
a reimplementation of Python's json.dumps, without all of the fancy
arguments that it supports, and currently without support for backslash
escapes in JSON string literals):
 
from parcon import *
import operator
cat_dicts = lambda x, y: dict(x.items() + y.items())
json = Forward()
number = (+Digit() + -(SignificantLiteral(".") + +Digit()))[flatten]["".join][float]
boolean = Literal("true")[lambda x: True] | Literal("false")[lambda x: False]
string = ('"' + Exact(ZeroOrMore(AnyChar() - CharIn('\"'))) +  '"')["".join]
null = Literal("null")[lambda x: None]
pair = (string + ":" + json[lambda x: (x,)])[lambda x: {x[0]: x[1]}]
json_object = ("{" + Optional(InfixExpr(pair, [(",", cat_dicts)]), {}) + "}")
json_list = ("[" + Optional(InfixExpr(json[lambda x: [x]], [(",", operator.add)]), []) + "]")
json << (json_object | json_list | string | boolean | null | number)
 
Thereafter, json.parse_string(text) can be used as a replacement for
Python's json.loads.
 
An interesting fact: the set of all Parcon parsers form a monoid with the
binary operation being the Then parser (or the + operator, since it produces a
Then parser) and the identity element being Return(None).

 
Package Contents
       
pargen (package)
pargon (package)
static

 
Classes
       
__builtin__.object
Expectation
EAnyChar
EAnyCharIn
ECustomExpectation
ERegex
EStringLiteral
EUnsatisfiable
Parser
And
AnyCase
AnyChar
Bind
CharIn
Alpha
Alphanum
Digit
Lower
Upper
Whitespace
Chars
Discard
Exact
Except
Expected
First
Forward
InfixExpr
Invalid
Keyword
Limit
Literal
SignificantLiteral
Longest
Not
OneOrMore
Optional
Present
Preserve
Regex
Repeat
Return
Then
Translate
Word
ZeroOrMore
Result

 
class Alpha(CharIn)
    Same as CharIn(upper_chars + lower_chars).
 
 
Method resolution order:
Alpha
CharIn
Parser
__builtin__.object

Methods defined here:
__init__(self)

Methods inherited from CharIn:
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Alphanum(CharIn)
    Same as CharIn(upper_chars + lower_chars + digit_chars).
 
 
Method resolution order:
Alphanum
CharIn
Parser
__builtin__.object

Methods defined here:
__init__(self)

Methods inherited from CharIn:
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class And(Parser)
    A parser that matches whatever its specified parser matches as long as its
specified check_parser also matches at the same location. This could be
considered the opposite of ExceptAnd matches when the second parser it's
passed also matches, while Except matches when the second parser it's
passed does not match. Wrapping the second parser with Not can make And
behave as Except and vice versa, although using whichever one makes more
sense will likely lead to more informative error messages when parsing
fails.
 
 
Method resolution order:
And
Parser
__builtin__.object

Methods defined here:
__init__(self, parser, check_parser)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class AnyCase(Parser)
    A case-insensitive version of Literal. Behaves exactly the same as Literal
does, but without regard to the case of the input.
 
If enough people request a version that returns the matched text instead of
None (send me an email if you're one of these people; my email is at the
top of this file, in the module docstring), I'll provide such a parser. For
now, though, you can use a Regex parser to accomplish the same thing.
 
 
Method resolution order:
AnyCase
Parser
__builtin__.object

Methods defined here:
__init__(self, text)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class AnyChar(Parser)
    A parser that matches any single character. It returns the character that
it matched.
 
 
Method resolution order:
AnyChar
Parser
__builtin__.object

Methods defined here:
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Bind(Parser)
    A parser that functions similar to Then, but that allows the second parser
to be determined from the value that the first parser produced. It's
constructed as Bind(parser, function). parser is the first parser to run.
function is a function that accepts one argument, the value that the first
parser produced. It will be called whenever the first parser succeeds; the
value that the first parser produced will be passed in, and the function
should return a second parser. This parser will then be applied immediately
after where the first parser finished parsing from (similar to how Then
starts its second parser parsing after where its first parser finished).
Bind then returns the value that the second parser produced.
 
Those of you familiar with functional programming will notice that this
parser implements a monadic bind, hence its name.
 
 
Method resolution order:
Bind
Parser
__builtin__.object

Methods defined here:
__init__(self, parser, function)
parse(self, text, position, end, whitespace)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class CharIn(Parser)
    A parser that matches a single character as long as it is in the specified
sequence (which can be a string or a list of one-character strings). It
returns the character matched.
 
 
Method resolution order:
CharIn
Parser
__builtin__.object

Methods defined here:
__init__(self, chars)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Chars(Parser)
    A parser that parses a specific number of characters and returns them as
a string. Chars(5), for example, would parse exactly five characters in a
row, and return a string of length 5. This would be essentially identical
to AnyChar()[5:5]["".join], except for two things: 1, the whitespace parser
is not applied in between each character parsed by Chars (although it is
applied just before the first character), and 2, Chars is much more
efficient than the aforementioned expression using AnyChar.
 
This can be used in combination with Bind to create a parser that parses
a binary protocol where a fixed number of bytes are present that specify
the length of the rest of a particular packet, followed by the rest of the
packet itself. For example, imagine a protocol where packets look like this:
 
length b1 b2 b3 ... blength
 
a.k.a. a byte indicating the length of the data carried in that packet,
followed by the actual data of the packet. Such a packet could be parsed
into a string containing the data of a single packet with this:
 
Bind(AnyChar(), lambda x: Chars(ord(x)))
 
 
Method resolution order:
Chars
Parser
__builtin__.object

Methods defined here:
__init__(self, number)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Digit(CharIn)
    Same as CharIn(digit_chars).
 
 
Method resolution order:
Digit
CharIn
Parser
__builtin__.object

Methods defined here:
__init__(self)

Methods inherited from CharIn:
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Discard(Parser)
    A parser that matches if the parser it's constructed with matches. It
consumes the same amount of input that the specified parser does, but this
parser always returns None as the result. Since instances of Then treat
None values specially, you'll likely use this parser in conjunction with
Then in some grammars.
 
 
Method resolution order:
Discard
Parser
__builtin__.object

Methods defined here:
__init__(self, parser)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class EAnyChar(Expectation)
    An expectation indicating that any character was expected.
 
 
Method resolution order:
EAnyChar
Expectation
__builtin__.object

Methods defined here:
__str__(self)
format(self)

Methods inherited from Expectation:
__repr__(self)

Data descriptors inherited from Expectation:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class EAnyCharIn(Expectation)
    An expectation indicating that any character in a particular sequence of
characters (a list of one-character strings, or a string containing the
expected characters) was expected.
 
 
Method resolution order:
EAnyCharIn
Expectation
__builtin__.object

Methods defined here:
__init__(self, chars)
__str__(self)
format(self)

Methods inherited from Expectation:
__repr__(self)

Data descriptors inherited from Expectation:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class ECustomExpectation(Expectation)
    An expectation indicating that some custom value was expected. This is used
when instances of the Expected parser fail. Users implementing their own
subclass of Parser that don't want to write a corresponding subclass of
Expectation but that find that none of the current subclasses of
Expectation fit their needs might also want to use ECustomExpectation.
 
 
Method resolution order:
ECustomExpectation
Expectation
__builtin__.object

Methods defined here:
__init__(self, message)
__str__(self)
format(self)

Methods inherited from Expectation:
__repr__(self)

Data descriptors inherited from Expectation:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class ERegex(Expectation)
    An expectation indicating that some regular expression was expected.
 
 
Method resolution order:
ERegex
Expectation
__builtin__.object

Methods defined here:
__init__(self, pattern_text)
__str__(self)
format(self)

Methods inherited from Expectation:
__repr__(self)

Data descriptors inherited from Expectation:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class EStringLiteral(Expectation)
    An expectation indicating that some literal string was expected. When
formatted, the string will be enclosed in double quotes. In the future, I
may have the representation as returned from Python's repr function be used
instead.
 
 
Method resolution order:
EStringLiteral
Expectation
__builtin__.object

Methods defined here:
__init__(self, text)
__str__(self)
format(self)

Methods inherited from Expectation:
__repr__(self)

Data descriptors inherited from Expectation:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class EUnsatisfiable(Expectation)
    An expectation indicating that there is no input that could have been
present that would have made the parser in question succeed or consume more
input. Invalid(), for example, returns EUnsatisfiable() since nothing will
make an Invalid match, and EStringLiteral, when it succeeds, returns
EUnsatisfiable() since there isn't any additional text that could be added
that would make EStringLiteral consume more of the input.
 
EUnsatisfiable is treated specially by format_failure; instances of it are
removed if there are expectations of any other type in the list provided
to format_failure. If there are not, the EUnsatisfiable with the greatest
position (expectations are stored as tuples of (position, Expectation)) is
used, and the message will look something like "At position n: expected
EOF".
 
 
Method resolution order:
EUnsatisfiable
Expectation
__builtin__.object

Methods defined here:
__str__(self)
format(self)

Methods inherited from Expectation:
__repr__(self)

Data descriptors inherited from Expectation:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Exact(Parser)
    A parser that returns whatever the specified parser returns, but Invalid()
will be passed as the whitespace parser to the specified parser when its
parse method is called. This allows for sections of the grammar to take
whitespace significantly, which is useful in, for example, string literals.
For example, the following parser, intended to parse string literals,
demonstrates the problem:
 
stringLiteral = '"' + ZeroOrMore(AnyChar() - '"') + '"'
result = stringLiteral.parse_string('"Hello, great big round world"')
 
After running that, result would have the value "Hello,greatbigroundworld".
This is because the whitespace parser (which defaults to Whitespace())
consumed all of the space in the string literal. This can, however, be
rewritten using Exact to mitigate this problem:
 
stringLiteral = '"' + Exact(ZeroOrMore(AnyChar() - '"')) + '"'
result = stringLiteral.parse_string('"Hello, great big round world"')
 
This parser produces the correct result, 'Hello, great big round world'.
 
 
Method resolution order:
Exact
Parser
__builtin__.object

Methods defined here:
__init__(self, parser, space_parser=Invalid())
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Except(Parser)
    A parser that matches and returns whatever the specified parser matches
and returns, as long as the specified avoidParser does not also match at
the same location. For example, Except(AnyChar(), Literal("*/")) would
match any character as long as that character was not a * followed
immediately by a / character. This would most likely be useful in, for
example, a parser designed to parse C-style comments.
 
 
Method resolution order:
Except
Parser
__builtin__.object

Methods defined here:
__init__(self, parser, avoidParser)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Expectation(__builtin__.object)
    NOTE: Most users won't need to know about this class or any of its
subclasses. They're usually only used internally by Parcon, but advanced
users may wish to use them.
 
An expectation. Instances of the various subclasses of this class are
provided as part of a Result object to indicate what could have made a
parser succeed if it failed, or consume more input if it succeeded.
Expectations are used to format the error message when Parser.parse_string
throws an exception because of a parse error.
 
This class should not be instantiated directly; instead, one of its various
subclasses should be used instead.
 
  Methods defined here:
__repr__(self)
__str__(self)
format(self)
Formats this expectation into a human-readable string. For example,
EStringLiteral("hello").format() returns '"hello"', and
EAnyCharIn("abc").format() returns 'any char in "abc"'.
 
Subclasses must override this method; Expectation's implementation of
the method raises NotImplementedError.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Expected(Parser)
    A parser that allows customization of the error message provided when the
parser it's created with fails. For example, let's say that you had a
parser that would parse numbers with decimals, such as 1.5:
 
decimal = +Digit() + "." + +Digit()
 
Now let's say that in your grammar, you included "true" and "false" as
things that could be in the same location as a decimal number:
 
something = decimal | "true" | "false"
 
If you call something.parse_string("bogus"), the resulting error message
will be:
 
At position 0: expected one of "true", "false", any char in "0123456789"
 
which isn't very pretty or informative. If, instead, you did this:
 
decimal = +Digit() + "." + +Digit()
decimal = Expected(decimal, "decimal number")
something = decimal | "true" | "false"
 
Then the error message would instead be something like:
 
At position 0: expected one of "true", "false", decimal number
 
which is more informative as to what's missing.
 
If the parameter remove_whitespace is True when constructing an instance
of Expected, whitespace will be removed before calling the underlying
parser's parse method. This will usually make error messages more accurate
about the position at which this whole Expected instance was expected.
If it's False, whitespace will not be removed, and it will be up to the
underlying parser to remove it; as a result, error messages will indicate
the position /before/ the removed whitespace as where the error occurred,
which is usually not what you want.
 
 
Method resolution order:
Expected
Parser
__builtin__.object

Methods defined here:
__init__(self, parser, expected_message, remove_whitespace=True)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class First(Parser)
    A parser that tries all of its specified parsers in order. As soon as one
matches, its result is returned. If none of them match, this parser fails.
 
 
Method resolution order:
First
Parser
__builtin__.object

Methods defined here:
__init__(self, *parsers)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Forward(Parser)
    A parser that allows forward-definition. In other words, you can create a
Forward and use it in a parser grammar, and then set the parser that it
actually represents later on. This is useful for defining grammars that
need to include themselves (for example, parentheses in a numerical
expression contain yet another numberical expression, which is an example
of where this would be used).
 
You create a forward with something like this:
 
forward = Forward()
 
You can then use it in your grammar as you would a normal parser. When
you're ready to set the parser that the Forward should actually represent,
you can do it either with:
 
forward << parser
 
or with:
 
forward.set(parser)
 
Both of them cause the forward to act as if it was really just the
specified parser.
 
The parser must be set before parse is called on anything using the
Forward instance.
 
You can also specify the parser when you create the Forward instance. This
is usually somewhat pointless, but it can be useful if you're simply trying
to create a mutable parser (the parser can be set into a Forward multiple
times, with the effect of changing the underlying parser each time).
 
 
Method resolution order:
Forward
Parser
__builtin__.object

Methods defined here:
__init__(self, parser=None)
__lshift__ = set(self, parser)
__repr__(self)
parse(self, text, position, end, space)
set(self, parser)
Sets the parser that this Forward should use. After you call this
method, this Forward acts just like it were really the specified parser.
 
This method can be called multiple times; each time it's called, it
changes the parser in use by this Forward instance.

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class InfixExpr(Parser)
    A parser that's created with a component parser and a series of operator
parsers, which can be literal strings (and will be translated to Literal
instances), and two-argument functions for each of these operator parsers.
It parses expressions of the form "component" or "component op component"
or "component op component op component" etc. For each op it encounters in
the result it parses, it calls the two-arg function supplied with that
operator, passing in the value of the parser on its left and the value of
the parser on its right. It then stores the result, and moves onto the next
operator, this time using the aforementioned result as the left-hand value
for the next operator.
 
This reduction of values proceeds from left to right, which makes InfixExpr
implement a left-associative infix grammar. In the future, there will be a
way to specify that certain operators should be right-associative instead.
 
If only a single component is present, InfixExpr will match that and return
whatever the component resulted in. If not even a single component is
present, InfixExpr will fail to match.
 
 
Method resolution order:
InfixExpr
Parser
__builtin__.object

Methods defined here:
__init__(self, component_parser, operators)
Creates an InfixExpr. component_parser is the parser that will parse
the individual components of the expression. operators is a list of
2-tuples; each tuple represents an operator, with the first item in the
tuple being a parser that parses the operator itself (or a literal
string, such as "+", "-", etc, which will be wrapped with a Literal
instance) and the second item being a two-arg function that will be
used to reduce components on either side of the operator to get a
result.
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Invalid(Parser)
    A parser that never matches any input and always fails.
 
 
Method resolution order:
Invalid
Parser
__builtin__.object

Methods defined here:
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Keyword(Parser)
    A parser that matches the specified parser as long as it is followed
immediately by the specified terminator parser, or by whitespace
(according to the current whitespace parser) if a terminator parser is not
specified.
 
 
Method resolution order:
Keyword
Parser
__builtin__.object

Methods defined here:
__init__(self, parser, terminator=None)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Limit(Parser)
    A parser that imposes a limit on how much input its underlying parser can
consume. All parsers, when asked to parse text, are passed the position
that they can parse to before they have to stop; normall this is the length
of the string being passed in. Limit, however, allows this to be set to a
smaller value.
 
When you construct a Limit instance, you pass in a parser that it will
call and the number of characters that the specified parser can consume.
If there aren't that many characters left in the input string, no limit is
placed on what the specified parser can consume.
 
 
Method resolution order:
Limit
Parser
__builtin__.object

Methods defined here:
__init__(self, length, parser)
__repr__(self)
parse(self, text, position, end, whitespace)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Literal(Parser)
    A parser that matches the specified literal piece of text. It succeeds
only if that piece of text is found, and it returns None when it succeeds.
If you need the return value to be the literal piece of text, you should
probably use SignificantLiteral instead.
 
 
Method resolution order:
Literal
Parser
__builtin__.object

Methods defined here:
__init__(self, text)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Longest(Parser)
    A parser that tries all of its specified parsers. The longest one that
succeeds is chosen, and its result is returned. If none of the parsers
succeed, Longest fails.
 
 
Method resolution order:
Longest
Parser
__builtin__.object

Methods defined here:
__init__(self, *parsers)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Lower(CharIn)
    Same as CharIn(lower_chars).
 
 
Method resolution order:
Lower
CharIn
Parser
__builtin__.object

Methods defined here:
__init__(self)

Methods inherited from CharIn:
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Not(Parser)
    A parser that matches only if the parser it's created with does not. If the
aforementioned parser fails, then Not succeeds, consuming no input and 
returning None. If the aforementioned parser succeeds, then Not fails.
 
 
Method resolution order:
Not
Parser
__builtin__.object

Methods defined here:
__init__(self, parser)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class OneOrMore(Parser)
    Same as ZeroOrMore, but requires that the specified parser match at least
once. If it does not, this parser will fail.
 
 
Method resolution order:
OneOrMore
Parser
__builtin__.object

Methods defined here:
__init__(self, parser)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Optional(Parser)
    A parser that returns whatever its underlying parser returns, except that
if the specified parser fails, this parser succeeds and returns the default
result specified to it (which, itself, defaults to None).
 
 
Method resolution order:
Optional
Parser
__builtin__.object

Methods defined here:
__init__(self, parser, default=None)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Parser(__builtin__.object)
    A parser. This class cannot itself be instantiated; you can only use one of
its subclasses. Most classes in this module are Parser subclasses.
 
The method you'll typically use on Parser objects is parse_string.
 
  Methods defined here:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse(self, text, position, end, space)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Present(Parser)
    A lookahead parser; it matches as long as the parser it's constructed with
matches at the specified position, but it doesn't actually consume any
input, and its result is None. If you need access to the result, you'll
probably want to use Preserve instead.
 
 
Method resolution order:
Present
Parser
__builtin__.object

Methods defined here:
__init__(self, parser)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Preserve(Parser)
    A lookahead parser; it matches as long as the parser it's constructed with
matches at the specified position, but it doesn't actually consume any
input. Unlike Present, however, Preserve returns whatever its underlying
parser returned, even though it doesn't consume any input.
 
 
Method resolution order:
Preserve
Parser
__builtin__.object

Methods defined here:
__init__(self, parser)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Regex(Parser)
    A parser that matches the specified regular expression. Its result depends
on the groups_only parameter passed to the constructor: if groups_only is
None (the default), the result is the string that the regex matches. If
groups_only is True, a list of the values that the groups in the regex
matched is true; for example, Regex("(..)(.)(....)", groups_only=True)
would parse the string "abcdefg" into ["ab", "c", "defg"]. If groups_only
is False, the string that the regex matched is provided as the first item
in the list, and the groups are provided as the rest of the items in the
list; the above example with groups_only=False would parse the string
"abcdefg" into ["abcdefg", "ab", "c", "defg"].
 
If you can avoid using Regex without requiring exorbitant amounts of
additional code, it's generally best to, since error messages given by
combinations of Parcon parsers are generally more informative than an
error message providing a regex. If you really need to use Regex but you
still want informative error messages, you could wrap your Regex instance
in an instance of Expected.
 
The specified regex can be either a string representing the regular
expression or a pattern compiled with Python's re.compile. If you want to
specify flags to the regex, you'll need to compile it with re.compile, then
pass the result into Regex.
 
Unlike the behavior of normal Python regex groups, groups that did not
participate in a match are represented in the returned list (if
groups_only is not None) by the empty string instead of None. If enough
people want the ability for None to be used instead (and my email address
is in the docstring for this module, at the top, so send me an email if
you're one of the people that want this), I'll add a parameter that can be
passed to Regex to switch this back to the usual behavior of using None.
 
 
Method resolution order:
Regex
Parser
__builtin__.object

Methods defined here:
__init__(self, regex, groups_only=None)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Repeat(Parser)
    A parser that matches its underlying parser a certain number of times. If
the underlying parser did not match at least min times, this parser fails.
This parser stops parsing after max times, even if the underlying parser
would still match. The results of all of the parses are returned as a list.
 
If max is None, no maximum limit will be enforced. The same goes for min.
 
Repeat(parser, 0, None) is the same as ZeroOrMore(parser), and
Repeat(parser, 1, None) is the same as OneOrMore(parser).
 
 
Method resolution order:
Repeat
Parser
__builtin__.object

Methods defined here:
__init__(self, parser, min, max)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Result(__builtin__.object)
    A result from a parser. Parcon users usually won't have any use for
instances of this class since it's primarily used internally by Parcon, but
if you're implementing your own Parser subclass, then you'll likely find
this class useful since you'll be returning instances of it.
 
  Methods defined here:
__init__(self, end, value, expected)
__nonzero__(self)
__repr__ = __str__(self)
__str__(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Return(Parser)
    A parser that always succeeds, consumes no input, and always returns a
value specified when the Return instance is constructed.
 
Those of you familiar with functional programming will notice that this
parser implements a monadic return, hence its name.
 
 
Method resolution order:
Return
Parser
__builtin__.object

Methods defined here:
__init__(self, value)
parse(self, text, position, end, whitespace)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class SignificantLiteral(Literal)
    A parser that matches the specified literal piece of text. Is succeeds
only if that piece of text is found. Unlike Literal, however,
SignificantLiteral returns the literal string passed into it instead of
None.
 
 
Method resolution order:
SignificantLiteral
Literal
Parser
__builtin__.object

Methods defined here:
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Literal:
__init__(self, text)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Then(Parser)
    A parser that matches the first specified parser followed by the second.
If neither of them matches, or if only one of them matches, this parser
fails. If both of them match, the result is as follows, assuming A and B
are the results of the first and the second parser, respectively:
 
If A is None, the result is B.
If B is None, the result is A.
If A and B are tuples, the result is A + B.
If A is a tuple but B is not, the result is A + (B,).
If B is a tuple but A is not, the result is (A,) + B.
Otherwise, the result is (A, B).
 
Named tuples (instances of classes created with collections.namedtuple) are
not treated as tuples in the above decision process. In fact, any subclass
of tuple is treated as if it were a completely separate object and not a
tuple at all.
 
 
Method resolution order:
Then
Parser
__builtin__.object

Methods defined here:
__init__(self, first, second)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Translate(Parser)
    A parser that passes the result of the parser it's created with, if said
parser matches successfully, through a function, and the function's return
value is then used as the result. The function is not called if the
specified parser fails.
 
For example, the following parser would use the flatten function provided
by parcon to flatten any lists and tuples produced by the parser
example_parser:
 
Translate(example_parser, flatten)
 
The following parser would likewise expect another_parser to produce a list
of strings and concatenate them together into a single result string:
 
Translate(another_parser, "".join)
 
 
Method resolution order:
Translate
Parser
__builtin__.object

Methods defined here:
__init__(self, parser, function)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Upper(CharIn)
    Same as CharIn(upper_chars).
 
 
Method resolution order:
Upper
CharIn
Parser
__builtin__.object

Methods defined here:
__init__(self)

Methods inherited from CharIn:
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Whitespace(CharIn)
    Same as CharIn(whitespace).
 
 
Method resolution order:
Whitespace
CharIn
Parser
__builtin__.object

Methods defined here:
__init__(self)
__repr__(self)

Methods inherited from CharIn:
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Word(Parser)
    A parser that parses a word consisting of a certain set of allowed
characters. A minimum and maximum word length can also be specified, as can
a set of characters of which the first character in the word must be a
member.
 
If min is unspecified, it defaults to 1. Max defaults to None, which places
no upper limit on the number of characters that can be in this word.
 
Word parses as many characters as it can that are in the specified
character set until it's parsed the specified maximum number of characters,
or it hits a character not in the specified character set. If, at that
point, the number of characters parsed is less than min, this parser fails.
Otherwise, it succeeds and produces a string containing all the characters.
 
min can be zero, which will allow this parser to succeed even if there are
no characters available or if the first character is not in init_chars.
The empty string will be returned in such a case.
 
 
Method resolution order:
Word
Parser
__builtin__.object

Methods defined here:
__init__(self, chars, init_chars=None, min=1, max=None)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class ZeroOrMore(Parser)
    A parser that matches the specified parser as many times as it can. The
results are collected into a list, which is then returned. Since
ZeroOrMore succeeds even if zero matches were made (the empty list will
be returned in such a case), this parser always succeeds.
 
 
Method resolution order:
ZeroOrMore
Parser
__builtin__.object

Methods defined here:
__init__(self, parser)
__repr__(self)
parse(self, text, position, end, space)

Methods inherited from Parser:
__add__(self, other)
__and__(self, other)
__getitem__(self, function)
__invert__(self)
__neg__(self)
__or__(self, other)
__pos__(self)
__radd__(self, other)
__rand__(self, other)
__ror__(self, other)
__rsub__(self, other)
__str__(self)
__sub__(self, other)
parse_string(self, string, all=True, whitespace=None)
Parses a string using this parser and returns the result, or throws an
exception if the parser does not match. If all is True (the default),
an exception will be thrown if this parser does not match all of the
input. Otherwise, if the parser only matches a portion of the input
starting at the beginning, just that portion will be returned.
 
whitespace is the whitespace parser to use; this parser will be applied
(and its results discarded) between matching every other parser while
attempting to parse the specified string. A typical grammar might have
this parser represent whitespace and comments. An instance of Exact can
be used to suppress whitespace parsing for a portion of the grammar,
which you would most likely use in, for example, string literals. The
default value for this parameter is Whitespace().

Data descriptors inherited from Parser:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Functions
       
failure(expected)
Returns a Result representing a failure of a parser to match. expected is
a list of expectations that would have had to be satisfied in the text
passed to the parser calling this method in order for it to potentially
succeed. Expectations are 2-tuples of the position at which some particular
piece of text was expected and an instance of one of the subclasses of
Expectation describing what was expected.
flatten(value)
A function that recursively flattens the specified value. Tuples and lists
are flattened into the items that they contain. The result is a list.
 
If a single non-list, non-tuple value is passed in, the result is a list
containing just that item. If, however, that value is None, the result is
the empty list.
 
This function is intended to be used as the function passed to Translate
where the parser passed to Translate could produce multiple nested lists of
tuples and lists, and a single, flat, list is desired.
format_failure(expected)
Formats a list of expectations into a failure message that typically looks
something like this:
 
At position n: expected one of x, y, or z
 
Expectations are provided in the same format as passed to the failure()
function.
match(end, value, expected)
Returns a Result representing a parser successfully matching. end is the
position in the string just after where the parser finished, or rather,
where the next parser after this one would be expected to start parsing.
value is the value that this parser resulted in, which is typically
specific to the parser calling this function. expected is a list of
expectations that would have allowed this parser to match more input than
it did; this parameter takes the same format as its corresponding parameter
to the failure function.
op_add(first, second)
op_and(first, second)
op_getitem(parser, function)
op_invert(parser)
op_neg(parser)
op_or(first, second)
op_pos(parser)
op_sub(first, second)
parse_space(text, position, end, space)
Repeatedly applies the specified whitespace parser to the specified text
starting at the specified position until it no longer matches. The result
of all of these parses will be discarded, and the location at which the
whitespace parser failed will be returned.
promote(value)
Converts a value of some type to an appropriate parser. Right now, this
returns the value as is if it's an instance of Parser, or Literal(value) if
the value is a string.

 
Data
        alpha_chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
alpha_word = Word('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop...OPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', 1, None)
alphanum_chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
alphanum_word = Word('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop...YZabcdefghijklmnopqrstuvwxyz0123456789', 1, None)
digit_chars = '0123456789'
id_word = Word('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop...OPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', 1, None)
lower_chars = 'abcdefghijklmnopqrstuvwxyz'
title_word = Word('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop...23456789', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 1, None)
upper_chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
whitespace = ' \t\r\n'