def grammar(**kwargs):
return adjective.grammar(**kwargs) | preposition.grammar(**kwargs) | {
# Raw nouns
Rule("NOUN^", [NounParser(is_plural=False)], passthru),
Rule("NOUNS^", [NounParser(is_plural=True)], passthru),
# Nouns without prepositions
Rule("NOUN", [RuleRef('NOUN^')], passthru),
Rule("NOUNS", [RuleRef('NOUNS^')], passthru),
# Nouns with prepositions (the car of (the owner of the building))
Rule("NOUN", [RuleRef('NOUN^'), RuleRef('PP')],
lambda state, data: data[1] + Interpretation(local=data[0].local.with_preposition_phrase(data[1].local))),
Rule("NOUNS", [RuleRef('NOUNS^'), RuleRef('PP')],
lambda state, data: data[1] + Interpretation(local=data[0].local.with_preposition_phrase(data[1].local))),
Rule("NOUN", [RuleRef('ADJECTIVE'), RuleRef('NOUN')],
lambda state, data: data[1] + Interpretation(local=data[1].local.with_adjective(data[0].local))),
Rule("NOUNS", [RuleRef('ADJECTIVE'), RuleRef('NOUNS')],
lambda state, data: data[1] + Interpretation(local=data[1].local.with_adjective(data[0].local))),
Rule("NOUN*", [RuleRef('NOUN')], passthru),
Rule("NOUN*", [RuleRef('NOUNS')], passthru),
}
def grammar(**kwargs):
return {
Rule("VERB_INF", [VerbParser(r'^\w+([^e]ed|ing|able)$', negate=True)],
passthru),
Rule("VERB_PP", [VerbParser(r'^\w+([^e]ed)$', negate=False)],
passthru),
Rule("VERB_BE", [VerbParser(r'be', negate=False)], passthru),
}
def grammar(**kwargs):
return recursive.grammar(**kwargs) | {
Rule('SPECIFIC_CLAIM', [RuleRef('BLOB')], blob_specific_claim),
Rule('CONDITIONAL_CLAIM', [RuleRef('BLOB')], blob_conditional_claim),
Rule('BLOB_WORD', [Expression(r'^(?!because|but|except)$')],
lambda state, data: data[0].local),
Rule('BLOB', [RuleRef('BLOB_WORD')], lambda state, data: [data[0]]),
Rule('BLOB', [RuleRef('BLOB'), RuleRef('BLOB_WORD')],
lambda state, data: data[0] + [data[1]]),
}
def grammar(**kwargs):
return category.grammar(**kwargs) | prototype.grammar(**kwargs) | verb.grammar(**kwargs) | {
Rule('CATEGORY', [Expression(r'^not?$'), RuleRef('CATEGORY')],
Negation.from_rule),
Rule('PROTOTYPE', [Expression(r'^not$'), RuleRef('PROTOTYPE')],
Negation.from_rule),
Rule('PROTOTYPES', [Expression(r'^not$'), RuleRef('PROTOTYPES')],
Negation.from_rule),
Rule('VERB_INF', [Expression(r'^not$'), RuleRef('VERB_INF')],
Negation.from_rule)
}
def grammar(**kwargs):
return noun.grammar(**kwargs) | {
Rule(
"PROTOTYPE", [Expression(r'^every|an?$'),
RuleRef("NOUN")],
lambda state, data: data[1] + Interpretation(local=Prototype(
data[1].local, article=data[0].local))),
Rule(
"PROTOTYPES", [RuleRef("NOUNS")], lambda state, data: data[0] +
Interpretation(local=Prototype(data[0].local))),
Rule(
"PROTOTYPES",
[Expression(r'^all|most|many|some$'),
RuleRef("NOUNS")], lambda state, data: data[0] + Interpretation(
local=Prototype(data[1].local, article=data[0].local))),
Rule("PROTOTYPE*", [RuleRef("PROTOTYPE")], passthru),
Rule("PROTOTYPE*", [RuleRef("PROTOTYPES")], passthru),
}
def grammar(**kwargs):
return {
Rule('PREPOSITION', [PrepositionSymbol()], passthru),
Rule(
'PP', [RuleRef('PREPOSITION'),
RuleRef('INSTANCE*')],
lambda state, data: data[1] + Interpretation(
local=PrepositionPhrase(data[0].local, data[1].local))),
Rule(
'PP', [RuleRef('PREPOSITION'),
RuleRef('PROTOTYPE*')],
lambda state, data: data[1] + Interpretation(
local=PrepositionPhrase(data[0].local, data[1].local))),
Rule(
'PP', [RuleRef('PREPOSITION'),
RuleRef('CATEGORY')],
lambda state, data: data[1] + Interpretation(
local=PrepositionPhrase(data[0].local, data[1].local))),
}
def and_rules(name: str, singleton: str, accept_singular: bool = False, first_singleton: Optional[str] = None, last_singleton: Optional[str] = None) -> Set[Rule]:
"""
Creates a mini-grammar of rules that are needed to parse 'A and B',
'A, B and C', 'A, B, C and D', etc. where A, B, C and D all are parseable
using the rule name passed using the singleton argument.
Grammar:
<As> ::= A_helper `and' A_last
<A_helper> ::= A_helper `,' A
<A_helper> ::= A_first
<As> ::= A
"""
if last_singleton is None:
last_singleton = singleton
if first_singleton is None:
first_singleton = singleton
helper = name + "_"
rules = {
# _ and C
Rule(name, [RuleRef(helper), Literal('and'), RuleRef(last_singleton)],
lambda state, data: data[0] + data[2] + Interpretation(local=data[0].local | OrderedSet([data[2].local]))),
# A, B # (allows for 'A, B and C')
Rule(helper, [RuleRef(helper), Literal(','), RuleRef(singleton)],
lambda state, data: data[0] + data[2] + Interpretation(local=data[0].local | OrderedSet([data[2].local]))),
# A (allows for 'A and B')
Rule(helper, [RuleRef(first_singleton)],
lambda state, data: data[0] + Interpretation(local=OrderedSet([data[0].local])))
}
if accept_singular:
rules |= {
Rule(name, [RuleRef(singleton)],
lambda state, data: data[0] + Interpretation(local=OrderedSet([data[0].local])))
}
return rules
def rule(self, name, symbols):
previous_frame = inspect.currentframe().f_back
(filename, line_number, function_name, lines,
index) = inspect.getframeinfo(previous_frame)
rule = Rule(name, symbols, file=filename, line=line_number)
self.rules.append(rule)
def wrapper(callback):
rule.callback = lambda state, data: callback(*data)
return callback
return wrapper
def test_claims():
grammar = general.grammar | specific.grammar | negation.grammar | {
Rule('ARGUMENT', [RuleRef('GENERAL_CLAIM')], passthru),
Rule('ARGUMENT', [RuleRef('SPECIFIC_CLAIM')], passthru),
}
sentences = map(tokenize, [
'Tweety is a bird',
'birds can fly',
'the birds can fly',
'Tweety can fly',
'Tweety can not fly',
'Tweety and Birdy are pretty',
])
# Uncomment this call to see the parse trees.
# override_callbacks(grammar)
parser = Parser(grammar, 'ARGUMENT')
test(parser, sentences)
def grammar(anaphora=True, **kwargs):
if anaphora:
singular = Instance
plural = GroupInstance
else:
singular = DumbInstance
plural = DumbGroupInstance
return name.grammar(**kwargs) | noun.grammar(**kwargs) | pronoun.grammar(**kwargs) | {
# Singular
Rule("INSTANCE", [RuleRef("PRONOUN")],
singular.from_pronoun_rule),
Rule("INSTANCE", [RuleRef("NAME")],
singular.from_name_rule),
Rule("INSTANCE", [Expression(r"^[Tt]he$"), RuleRef("NOUN")],
singular.from_noun_rule),
Rule("INSTANCE", [Expression(r"^[Hh]is|[Hh]er|[Tt]heir$"), RuleRef("NOUN")],
singular.from_noun_rule),
# Plural
Rule("INSTANCES", [RuleRef("PRONOUNS")],
plural.from_pronoun_rule),
Rule("INSTANCES", [RuleRef("NAMES")],
plural.from_names_rule),
Rule("INSTANCES", [Expression(r"^[Tt]he$"), RuleRef("NOUNS")],
plural.from_noun_rule),
Rule("INSTANCES", [Expression(r"^[Hh]is|[Hh]er|[Tt]heir$"), RuleRef("NOUNS")],
plural.from_noun_rule),
# Shortcuts
Rule("INSTANCE*", [RuleRef("INSTANCE")], passthru),
Rule("INSTANCE*", [RuleRef("INSTANCES")], passthru),
}
def apply(self, vpc):
"""
returns a list of new security groups that will be added
"""
assert vpc is not None
# make sure we're up to date
self.reload_remote_groups()
vpc_groups = self.vpc_groups(vpc)
self._apply_groups(vpc)
# reloads groups from AWS, the authority
self.reload_remote_groups()
vpc_groups = self.vpc_groups(vpc)
groups = {k.name:k for k in vpc_groups}
for x,y in self.config.items():
# process 1 security group at a time
group = groups[x]
if y.get('rules'):
# apply all rule changes
rules = [Rule.parse(rule) for rule in y.get('rules')]
rules = list(itertools.chain(*rules))
rules = self.filter_existing_rules(rules, group)
# need to use chain because multiple rules can be created for a single stanza
for rule in rules:
group_name = groups.get(rule.group_name, None)
if group_name and rule.address:
raise Exception("Can't auth an address and a group")
logger.debug("Authorizing %s %s %s to address:%s name:%s", rule.protocol,
rule.from_port, rule.to_port, rule.address, rule.group_name)
group_to_authorize = groups.get(rule.group_name, None)
try:
group.authorize(rule.protocol,
rule.from_port,
rule.to_port,
rule.address,
group_to_authorize, None)
except Exception as e:
print "could not authorize group %s" % group_to_authorize
raise
# apply rules
return self
def grammar(**kwargs):
return {
# Singular
Rule("PRONOUN", [Expression(r'^[Hh]e$')], passthru),
Rule("PRONOUN", [Expression(r'^[Ss]he$')], passthru),
Rule("PRONOUN", [Expression(r'^[Ii]t$')], passthru),
# Plural
Rule("PRONOUNS", [Expression(r'^[Tt]hey$')], passthru),
# Undetermined
Rule("PRONOUN", [Expression(r'^[Ss]omeone$')], passthru),
Rule("PRONOUN", [Expression(r'^[Ss]omething$')], passthru),
}
def grammar(**kwargs):
return and_rules('NAMES', 'NAME', accept_singular=False) | {
Rule("NAME", [NameParser()], passthru)
}
def grammar(**kwargs):
return and_rules('SPECIFIC_CLAIMS', 'SPECIFIC_CLAIM', accept_singular=True) \
| and_rules('SPECIFIC_CLAIMS_CONDITIONAL_FIRST', 'SPECIFIC_CLAIM', first_singleton='CONDITIONAL_CLAIM') \
| and_rules('SPECIFIC_CLAIMS_CONDITIONAL_LAST', 'SPECIFIC_CLAIM', last_singleton='CONDITIONAL_CLAIM') \
| {
Rule('ARGUMENT', [RuleRef('SENTENCE')],
lambda state, data: data[0]),
Rule('ARGUMENT', [RuleRef('ARGUMENT'), RuleRef('SENTENCE')],
lambda state, data: data[0] + data[1]),
Rule('SENTENCE', [RuleRef('SUPPORTED_CLAIM'), Literal('.')],
lambda state, data: data[0]),
Rule('SENTENCE', [RuleRef('ATTACKED_CLAIM'), Literal('.')],
lambda state, data: data[0]),
Rule('SUPPORTED_CLAIM', [RuleRef('SPECIFIC_CLAIM'), Literal('because'), RuleRef('SPECIFIC_CLAIMS')],
lambda state, data: data[0] + data[2] + Interpretation(argument=relation(Relation.SUPPORT, data[0].local, specifics=data[2].local), local=data[0].local)),
Rule('SUPPORTED_CLAIM', [RuleRef('SUPPORTED_CLAIM_WITH_WARRANT')],
lambda state, data: data[0]),
Rule('SUPPORTED_CLAIM_WITH_WARRANT', [RuleRef('SPECIFIC_CLAIM'), Literal('because'), RuleRef('SPECIFIC_CLAIMS_CONDITIONAL_FIRST')],
lambda state, data: data[0] + data[2] + Interpretation(argument=relation(Relation.SUPPORT, data[0].local, general=data[2].local[0], specifics=data[2].local[1:]), local=data[0].local)),
Rule('SUPPORTED_CLAIM_WITH_WARRANT', [RuleRef('SPECIFIC_CLAIM'), Literal('because'), RuleRef('SPECIFIC_CLAIMS_CONDITIONAL_LAST')],
lambda state, data: data[0] + data[2] + Interpretation(argument=relation(Relation.SUPPORT, data[0].local, general=data[2].local[-1], specifics=data[2].local[:-1]), local=data[0].local)),
Rule('ATTACKED_CLAIM', [RuleRef('SPECIFIC_CLAIM'), Expression(r'^but|except$'), RuleRef('SPECIFIC_CLAIMS')],
lambda state, data: data[0] + data[2] + Interpretation(argument=relation(Relation.ATTACK, data[0].local, specifics=data[2].local), local=data[0].local)),
Rule('ATTACKED_CLAIM', [RuleRef('ATTACKED_CLAIM_WITH_WARRANT')],
lambda state, data: data[0]),
Rule('ATTACKED_CLAIM_WITH_WARRANT', [RuleRef('SPECIFIC_CLAIM'), Expression(r'^but|except$'), RuleRef('SPECIFIC_CLAIMS_CONDITIONAL_FIRST')],
lambda state, data: data[0] + data[2] + Interpretation(argument=relation(Relation.ATTACK, data[0].local, general=data[2].local[0], specifics=data[2].local[1:]), local=data[0].local)),
Rule('ATTACKED_CLAIM_WITH_WARRANT', [RuleRef('SPECIFIC_CLAIM'), Expression(r'^but|except$'), RuleRef('SPECIFIC_CLAIMS_CONDITIONAL_LAST')],
lambda state, data: data[0] + data[2] + Interpretation(argument=relation(Relation.ATTACK, data[0].local, general=data[2].local[-1], specifics=data[2].local[:-1]), local=data[0].local)),
# Experimental, don't know if I want this
# Rule('SUPPORTED_CLAIM', [RuleRef('SPECIFIC_CLAIM'), Literal('because'), RuleRef('CONDITIONAL_CLAIM')],
# lambda state, data: data[0] + data[2] + assume(data[0].local, data[2].local)),
# Attacking a warrant?
Rule('SUPPORTED_CLAIM', [RuleRef('SUPPORTED_CLAIM'), Expression(r'^but|except$'), RuleRef('SPECIFIC_CLAIMS')],
lambda state, data: data[0] + data[2] + Interpretation(argument=relation(Relation.ATTACK, data[0].local, specifics=data[2].local))),
Rule('SUPPORTED_CLAIM', [RuleRef('SUPPORTED_CLAIM_WITH_WARRANT'), Expression(r'^but|except$'), RuleRef('SPECIFIC_CLAIMS')],
lambda state, data: data[0] + data[2] + Interpretation(argument=relation(Relation.ATTACK, warrant_relation(data[0]), specifics=data[2].local)))
}
def add_rule(self, symbol, expansion):
assert isinstance(symbol, Symbol)
for s in expansion:
assert isinstance(s, Symbol)
self.rules.append(Rule(symbol, expansion))
def post_multiple_rule(env, loc, lhs, block):
seq = []
for rhs, attribute, mapping in block:
seq.append(Rule(lhs.value, rhs, attribute, mapping))
return seq
special => special(symbol string): symbol colon:":" string
"""
from parser import Parser, Rule
import sys
symboltab = {
'=': 'equals',
'=>': 'arrow',
':': 'colon',
'(': 'lp',
')': 'rp',
}
grammar = [
# statement level syntax
Rule('file', ['statement'],
'pass'),
Rule('file', ['file', 'newline', 'statement'],
'concat', [0, 2]),
Rule('statement', ['symbol', 'arrow', 'rule'],
'single_rule', [0, 2]),
Rule('statement', ['symbol', 'arrow', 'indent', 'block', 'dedent'],
'multiple_rule', [0, 3]),
Rule('statement', ['special'],
'empty_list', []),
Rule('block', ['rule'],
'first'),
Rule('block', ['block', 'newline', 'rule'],
'append', [0, 2]),
def rule(self, name, symbols):
previous_frame = inspect.currentframe().f_back
(filename, line_number, function_name, lines,
index) = inspect.getframeinfo(previous_frame)
rule = Rule(name, symbols, file=filename, line=line_number)
self.rules.append(rule)
def wrapper(callback):
rule.callback = lambda state, data: callback(*data)
return callback
return wrapper
en_grammar = Grammar([
Rule('name', [Tag('NNP')], merge),
Rule('name', [RuleRef('name'), Tag('NNP')], merge), # longer names
Rule('name', [RuleRef('name'), Tag('NNPS')], merge), # Catholic Swedes
Rule('name', [Literal('Tweety')], merge),
Rule('instance', [RuleRef('name')],
lambda state, data: Entity(name=data[0])),
Rule(
'instance',
[Tag('PRP')], # "I"
lambda state, data: Entity(pronoun=data[0])),
Rule('instance',
[RuleRef('def-dt'),
RuleRef('adjectives?'),
RuleRef('noun')],
lambda state, data: Entity(noun=data[0] + data[1] + data[2])),
Rule(
def grammar(**kwargs):
return {Rule("ADJECTIVE", [Expression(r"^\w+$")], passthru)}
def __init__(self, pattern: str, negate=False) -> None:
self.pattern = re.compile(pattern)
self.negate = negate
def test(self, literal: str, position: int, state: State) -> bool:
accept = re.match(self.pattern, literal) is not None
return not accept if self.negate else accept
def __repr__(self):
return "ReSymbol({}{!r})".format("¬" if self.negate else "", self.pattern)
rules = list(parse_rule(expression, callback) for expression, callback in grammar)
rules += [
Rule("NOUN", [NounSymbol(plural=False)], passthru),
Rule("NOUNS", [NounSymbol(plural=True)], passthru),
Rule("NAME", [NameSymbol()], lambda state, data: data[0]),
Rule("PRONOUN", [PronounSymbol()], lambda state, data: data[0]),
Rule("VERB_INF", [ReSymbol(r'^\w+([^e]ed|ing|able)$', negate=True)], lambda state, data: Verb(data[0])),
Rule("VERB_NOUN", [ReSymbol(r'^\w+([^e]ed|ing|able)$')], lambda state, data: Verb(data[0]))
]
start = "START"
Operation = ArgumentativeDiscourseUnit # for compatibility for now
if __name__ == '__main__':
try:
for sentence in sentences[:4]:
parser = Parser(rules, start)
def grammar(**kwargs):
return {
# Rule("CATEGORY", [Expression(r'.+')],
# lambda state, data: data[0] + Interpretation(local=Category(data[0].local)))
Rule('CATEGORY', [RuleRef('NOUN*')], passthru),
}
