def prepare_terms(items):
main = None
terms = []
for index, item in enumerate(items):
assert_type(item, (Predicate, Rule, Main))
if isinstance(item, Main):
if main is not None:
raise ValueError('>1 main')
main = index
item = item.term
terms.append(item)
if main is None:
main = 0
return terms, main
def __init__(self, **kwargs):
self.raw = None
self.__repeatable = set()
for key in self.__attributes__:
attribute = getattr(self, key)
if isinstance(attribute, RepeatableFactAttribute):
self.__repeatable.add(key)
value = []
else:
value = attribute.default
setattr(self, key, value)
self.__modified = set()
for key, value in kwargs.items():
if key not in self.__attributes__:
raise TypeError(key)
if key in self.__repeatable:
assert_type(value, list)
setattr(self, key, value)
self.__modified.add(key)
def __init__(self, rule, relation):
from yargy.relations import Relation
super(RelationRule, self).__init__(rule)
assert_type(relation, Relation)
self.relation = relation
def __init__(self, rule, interpretator):
from yargy.interpretation import Interpretator
super(InterpretationRule, self).__init__(rule)
assert_type(interpretator, Interpretator)
self.interpretator = interpretator
def __init__(self, rule, name):
super(NamedRule, self).__init__(rule)
assert_type(name, string_type)
self.name = name
def __init__(self, rule, reverse_repeatable, reverse_optional):
WrapperRule.__init__(self, rule)
assert_type(reverse_repeatable, bool)
assert_type(reverse_optional, bool)
self.reverse_repeatable = reverse_repeatable
self.reverse_optional = reverse_optional
def __init__(self, rule, reverse):
WrapperRule.__init__(self, rule)
assert_type(reverse, bool)
self.reverse = reverse
def __init__(self, relations):
super(RelationsComposition, self).__init__()
relations = list(relations)
for relation in relations:
assert_type(relation, Relation)
self.relations = relations
def __init__(self, predicates):
predicates = list(predicates)
for predicate in predicates:
assert_type(predicate, Predicate)
self.predicates = predicates
def __init__(self, term):
from yargy.rule import Rule
from yargy.predicates import Predicate
assert_type(term, (Rule, Predicate))
self.term = term
def __init__(self, relation):
super(NotRelation, self).__init__()
assert_type(relation, Relation)
self.relation = relation
def __init__(self, relations):
super(RelationsComposition, self).__init__()
relations = list(relations)
for relation in relations:
assert_type(relation, Relation)
self.relations = relations
def __init__(self, relation):
super(NotRelation, self).__init__()
assert_type(relation, Relation)
self.relation = relation
def __init__(self, productions):
productions = list(productions)
for production in productions:
assert_type(production, Production)
self.productions = productions
def __init__(self, rules):
rules = list(rules)
for rule in rules:
assert_type(rule, Rule)
self.rules = rules
def __init__(self, predicates):
predicates = list(predicates)
for predicate in predicates:
assert_type(predicate, Predicate)
self.predicates = predicates
def __init__(self, rule):
assert_type(rule, Rule)
self.rule = rule
def __init__(self, predicate):
assert_type(predicate, Predicate)
self.predicate = predicate
def __init__(self, term):
from yargy.rule import Rule
from yargy.predicates import Predicate
assert_type(term, (Rule, Predicate))
self.term = term
