def test_reMach(self):
msg = """
===
RegExp:%s
Text:%s
NOT MACH ===
"""
lanRules = Rules()
Format = lanRules.get('Format', 'pattern')
# print(lanRules.get('Filter', 'pattern'))
Filter = lanRules['Filter']['pattern']
Blank = lanRules['Blank']['pattern']
print(Blank)
testSamples = [
# [resault,regExp,Text,re.report]
[True, r'hello', 'hello world!'],
[True, Format, 'E\tE/_1_=English\tS/_1_=简体中文'],
[False, Format, 'E\tE/_2_=English\tS/_1_=简体中文'],
[True, Format, 'F\tF/_16_=la touche # pour entrer espace\tS/_16_=#键输入空格\t35'],
[True, Filter, 'E\t#E/_1_=English\tS/_1_=简体中文'],
[True, Filter, 'E\tE/_1_=English\t#S/_1_=简体中文'],
[True, Filter, 'E\tE/_1_=English\tS/1_=简体中文'], # 基准字段格式检测错误，也会排除
[True, Filter, 'G\tF/_16_=la touche # pour entrer espace\tS/_1k6_=#键输入空格 35'],
[True, Blank, 'E/_1_=Eng lish'],
]
for mustRet, regExp, text in testSamples:
resault = Rules().Test(regExp, text)
emsg = msg % (regExp, text)
self.assertEqual(resault, mustRet, emsg)
pass
def __init__(self, objective, parent=None):
super(QuestionWidget, self).__init__(parent)
self.objective = objective
self.memRules = Rules("rulelist.json")
self.reasoned = []
# Get consequents, antecedents and list of rules pertaining the objective
related = self.memRules.GetRelatedRules(self.objective)
self.cons = related["CONS"]
self.ants = related["ANTS"]
# Generate question list
self.question_list = []
for con in self.cons[1:]:
self.question_list.append(con)
for ant in self.ants:
self.question_list.append(ant)
self.question = ""
self.ruleHeap = Rules()
for rule in related["RULES"]:
self.ruleHeap.CreateRule(rule)
# Value log will be a workmemory object
self.valueLog = WorkMemory()
self.lbl = QLabel('Especifique el valor de "<ID>":')
self.value_edit = QComboBox()
self.value_edit.addItem("T")
self.value_edit.addItem("F")
self.replace_btn = QPushButton("Replace")
self.replace_btn.clicked.connect(self.Replace)
self.rules_heap = QPlainTextEdit()
self.rules_heap.setReadOnly(True)
self.value_logs = QPlainTextEdit()
self.value_logs.setReadOnly(True)
self.hlayout1 = QHBoxLayout()
self.hlayout1.addWidget(self.lbl)
self.hlayout1.addWidget(self.value_edit)
self.hlayout1.addWidget(self.replace_btn)
self.hlayout2 = QHBoxLayout()
self.hlayout2.addWidget(self.rules_heap)
self.hlayout2.addWidget(self.value_logs)
self.main_layout = QVBoxLayout()
self.main_layout.addLayout(self.hlayout1)
self.main_layout.addLayout(self.hlayout2)
self.UpdateValueLog()
self.UpdateRuleHeap()
self.SetNextQuestion()
self.setLayout(self.main_layout)
self.setWindowTitle("Objective Reasoning - Questioning")
self.show()
def make_move(self, move: str, white):
match = self.pattern.match(move)
piece_type = Pieces.get(
'p' if match.group(1) == '' else match.group(1), white=True)
move = match.group(2).replace('x', '')
promotion = match.group(3)
rules = Rules()
rules.put(self._board,
self.en_passant,
self.wk,
self.wq,
self.bk,
self.bq,
promote=None if promotion == '' else promotion)
exact_row, exact_col = '', ''
if move.lower() == 'o-o':
if white:
move = 'g1'
else:
move = 'g8'
piece_type = 'K'
elif move.lower() == 'o-o-o':
if white:
move = 'c1'
else:
move = 'c8'
piece_type = 'K'
elif len(move) == 3:
char = move[0]
move = move[-2:]
if char.isdigit():
exact_col = char
else:
exact_row = char
pieces, possible_moves = rules.pieces, rules.possible_moves
for piece, moves in zip(pieces, possible_moves):
if piece_type == Pieces.get(piece.type, True) and piece.is_white == white and move in moves \
and exact_row in piece.square and exact_col in piece.square:
board_copy = self._board.copy()
board_copy.update_squares(*rules.make_move(piece.square, move))
rules_check = Rules()
rules_check.put(board_copy, self.en_passant, self.wk, self.wq,
self.bk, self.bq)
status = rules_check.status(white)
if status == Rules.NORMAL:
previous_board = self._board.copy()
self._board.update_squares(
*rules.make_move(piece.square, move))
self.update_castle(*Rules.castle_rights(self._board))
self.en_passant = Rules.find_en_passant(
self._board, previous_board)
break
def sort_hand(cards, game_type):
if not game_type:
return sorted(cards, key=lambda card: Rules().cards.index(card))
sorted_trumps = Rules().get_sorted_trumps(game_type=game_type)
trumps = sorted([card for card in cards if card in sorted_trumps], key= lambda card : sorted_trumps.index(card))
non_trumps = sorted([card for card in cards if card not in sorted_trumps], key=lambda card: Rules().cards.index(card))
return non_trumps + trumps
def __init__(self,
base_directory=None,
verbose=False,
being_tested=False,
ignore_temp_rules=False,
ignore_specific_rules=False):
"""Creates a new DepsBuilder.
Args:
base_directory: local path to root of checkout, e.g. C:\chr\src.
verbose: Set to True for debug output.
being_tested: Set to True to ignore the DEPS file at tools/checkdeps/DEPS.
ignore_temp_rules: Ignore rules that start with Rule.TEMP_ALLOW ("!").
"""
base_directory = (base_directory or os.path.join(
os.path.dirname(__file__), os.path.pardir, os.path.pardir))
self.base_directory = os.path.abspath(
base_directory) # Local absolute path
self.verbose = verbose
self._under_test = being_tested
self._ignore_temp_rules = ignore_temp_rules
self._ignore_specific_rules = ignore_specific_rules
# Set of normalized paths
self.git_source_directories = _GitSourceDirectories(
self.base_directory)
# Map of normalized directory paths to rules to use for those
# directories, or None for directories that should be skipped.
# Normalized is: absolute, lowercase, / for separator.
self.directory_rules = {}
self._ApplyDirectoryRulesAndSkipSubdirs(Rules(), self.base_directory)
def main():
rules = Rules()
rulefunc = getattr(rules, rule)
lastfld = None
# t = Thing(fld, cell, Location(0,0))
# t.program = list("ddrrrull")
# things.generate()
rooms = add_rooms()
# for r in rooms:
# for l in r.tpoints: fld.put('*', Location(l))
# print [str(r) for r in rooms]
corridors = Corridors(fld, rooms)
corridors.create()
fld.display()
return
for i in range(period):
rules.n = i
for thing in things:
thing.movep()
# if p: t.movep()
for location in fld:
val = fld.value(location)
rulefunc(fld, location, val, len(fld.live_neighbours(location)))
fld.display()
print ' ' + "%d/%d add:%d" % (i + 1, period, rules.add)
sleep(interval)
lastfld = fld.field
def __init__(self, allmessages, debug=False):
#generate all ``Rule``s that the ``Message``s will be checked against
rules = Rules().rules
self.document_plans = []
for index, book in enumerate(allmessages.books):
before = time()
messages = book.messages.values(
) #all messages about a single book
plan = generate_textplan(messages, rules, book.book_score)
after = time()
time_diff = after - before
self.document_plans.append(plan)
if debug == True:
print "Plan {0}: generated in {1} seconds.\n".format(
index, time_diff, plan)
book_title = book.messages['id']['title']
if index > 0:
lastbook = allmessages.books[index - 1]
lastbook_title = lastbook.messages['id']['title']
print "Comparing '{0}' " \
"with '{1}':\n\n{2}".format(book_title,
lastbook_title, plan)
else:
print "Describing '{0}':\n\n{1}".format(book_title, plan)
def __init__(self):
self.games_board = Board(8)
self.game_view = View(self.games_board)
self.rules_game = Rules(self.games_board)
self.player_one = HumanPlayer(Disk.DARK)
self.player_two = RandomPlayer(Disk.LIGHT)
def setSeed(self, seed):
if seed == None:
seed = int(time.time() * 1000) % 2**32
np.random.seed(seed)
random.seed(seed)
torch.manual_seed(seed)
self.rules = Rules()
def __init__(self, dealer):
self.rules = Rules()
self.dealer = dealer
self.game_type = [None, None]
self.game_player = None
self.first_player = (dealer + 1) % 4
self.trick_number = 0
self.played_cards = 0
self.game_stage = None
# who wants to play what
self.bidding_round = [[None, None] for x in range(4)]
# who doubled the game (kontra / retour)
self.contra_retour = []
# cards ordered by players
self.course_of_game_playerwise = [[[None, None] for x in range(4)]
for y in range(8)]
# cards ordered by the time they were played
self.course_of_game = [[[None, None] for x in range(4)]
for y in range(8)]
# which player took the trick
self.trick_owner = [None] * 8
self.scores = [0, 0, 0, 0]
#for debugging purposes remember probs for picking an action
self.action_probabilities = [[[None, None] for x in range(4)]
for y in range(11)]
def test_four_of_a_kind(self):
hand = Hand()
for i in range(4):
hand.hand[i]._Die__face = 1
for i in range(4, 5):
hand.hand[i]._Die__face = 2
self.assertEqual(Rules().four_of_a_kind(hand), 6)
def test_three_of_a_kind(self):
hand = Hand()
for i in range(3):
hand.hand[i]._Die__face = 1
for i in range(3, 5):
hand.hand[i]._Die__face = 2
self.assertEqual(Rules().three_of_a_kind(hand), 7)
def parsing(filename):
rules = Rules()
try:
file = open(filename, "r")
except IOError:
print "Error: Files does not exist"
sys.exit(1)
for line in file.readlines():
sharp_pos = line.find("#")
equal_pos = line.find("=")
mark_pos = line.find("?")
len_line = len(line)
if (len_line == 1):
continue
else:
if (equal_pos == 0):
rules.set_initial_facts(line[1:])
if (mark_pos == 0):
rules.set_goals(line[1:])
if (equal_pos < 0 and mark_pos < 0) or \
(equal_pos > 0 and mark_pos < 0) :
if (sharp_pos > 0):
rules.parse(line.split("#")[0])
elif (sharp_pos < 0):
rules.parse(line)
if (len(rules.goals) == 0):
print "No Goal"
sys.exit()
if (len(rules.data) == 0):
print "No Rule"
sys.exit()
rules.fact = ''.join(set(rules.fact))
rules.initial_fact = ''.join(set(rules.initial_fact))
rules.goals = ''.join(set(rules.goals))
return rules
def findrule(ruletype="", attribute="", value=""):
"""
debugging: find rules that have a certain ruleType and some
attribute-value pair
Example: findrule("Concession", "nucleus", "usermodel_match") finds
rules of type 'Concession' where rule.nucleus == 'usermodel_match'.
"""
rules = Rules().rule_dict
matching_rules = {}
if ruletype == "":
for index, (name, rule) in enumerate(rules.iteritems()):
if getattr(rule, attribute) is value:
print "rule {0} - {1}:\n{2}".format(index, name, rule)
matching_rules[name] = rule
elif attribute == "":
for index, (name, rule) in enumerate(rules.iteritems()):
if rule.ruleType is ruletype:
print "rule {0} - {1}:\n{2}".format(index, name, rule)
matching_rules[name] = rule
else:
for index, (name, rule) in enumerate(rules.iteritems()):
if rule.ruleType is ruletype and getattr(rule, attribute) is value:
print "rule {0} - {1}:\n{2}".format(index, name, rule)
matching_rules[name] = rule
return matching_rules
def __init__(self, size, session, scope, threads):
super().__init__(size, session, scope, threads)
self.autoresolve = False
self.rules = Rules(size, FLAGS.connections)
self.test_mode = False
self.epsilon = 0.0
self.board = None
def find_applicable_rules(messages):
"""
debugging: find out which rules are directly (i.e. without forming ConstituentSets first) applicable to your messages
:type messages: ``list`` of ``Message``s or
``Messages``
"""
if type(messages) is list: # is 'messages' a list of Message() instances?
pass
elif isinstance(messages, Messages):
messages = messages.messages.values()
for name, rule in Rules().rule_dict.iteritems():
try:
if rule.get_options(messages) != []:
nuc_candidates = \
[rulename for (rulename, msg) in rule.nucleus]
sat_candidates = \
[rulename for (rulename, msg) in rule.satellite]
print "{0}: {1} - {2}, {3} - is directly applicable and results in \n\t{4}\n\n".format(
name, rule.ruleType, nuc_candidates, sat_candidates,
rule.get_options(messages))
except:
print "ERROR: Could not check if rule {0} is applicable. Possible solution: test if the rule's conditions are specified appropriately.\n\n".format(
name)
def select_scoring(self, hand):
msg = "Choose which scoring to use "\
"(leave empty to show available rows): "
scoreboard_row = False
score_saved = False
while not scoreboard_row and not score_saved:
scoreboard_row = input(msg)
if scoreboard_row.strip() == "":
self.show_scoreboard_points()
scoreboard_row = False
continue
try:
scoreboard_row = int(re.sub('[^0-9,]', '', scoreboard_row))
except ValueError:
print("You entered something other than a number.")
print("Please try again")
scoreboard_row = False
continue
if scoreboard_row > len(self.scoreboard_rows):
print("Please select an existing scoring rule.")
scoreboard_row = False
continue
else:
score_saved = self.set_scoreboard_row_value(
int(scoreboard_row),
Rules().rules_map[int(scoreboard_row)](hand))
def __init__(self,
base_directory=None,
verbose=False,
being_tested=False,
ignore_temp_rules=False,
skip_tests=False):
"""Creates a new DepsChecker.
Args:
base_directory: OS-compatible path to root of checkout, e.g. C:\chr\src.
verbose: Set to true for debug output.
being_tested: Set to true to ignore the DEPS file at tools/checkdeps/DEPS.
"""
self.base_directory = base_directory
self.verbose = verbose
self._under_test = being_tested
self._ignore_temp_rules = ignore_temp_rules
self._skip_tests = skip_tests
if not base_directory:
self.base_directory = os.path.abspath(
os.path.join(os.path.abspath(os.path.dirname(__file__)), '..', '..'))
self.results_formatter = results.NormalResultsFormatter(verbose)
self.git_source_directories = set()
self._AddGitSourceDirectories()
# Map of normalized directory paths to rules to use for those
# directories, or None for directories that should be skipped.
self.directory_rules = {}
self._ApplyDirectoryRulesAndSkipSubdirs(Rules(), self.base_directory)
def __init__(self, color):
"""
Initializing the class with its color
:param color: Disk.DARK or Disk.LIGHT
"""
super().__init__(color)
self.rules = Rules()
def test_calctime400():
r = Rules("data/rules.txt")
assert r.calc_time(0, 400) == (0, 60)
assert r.calc_time(300, 400) == (540, 1200)
assert r.calc_time(330, 400) == (597, 1320)
assert r.calc_time(400, 400) == (728, 1620)
assert r.calc_time(440, 400) == (728, 1620)
def __init__(self):
self.train_episodes = 20000 # max number of episodes to learn from
self.gamma = 1 # future reward discount
# Exploration parameters
self.explore_start = 1.0 # exploration probability at start
self.explore_stop = 0.01 # minimum exploration probability 0.01
self.decay_rate = 0.0001 # exponential decay rate for exploration prob 0.00001
# Network parameters
self.hidden_size1 = 128 # number of units in each Q-network hidden layer 64
self.hidden_size2 = 64
self.hidden_size3 = 32
self.learning_rate = 0.000005 # Q-network learning rate 0.00001
# Memory parameters
self.memory_size = 1000 # memory capacity
self.batch_size = 64 # experience mini-batch size
self.pretrain_length = self.batch_size * 8 # number experiences to pretrain the memory
tf.reset_default_graph()
self.QNetworkCard = QNetworkCard(name='main',
hidden_size1=self.hidden_size1,
hidden_size2=self.hidden_size2,
hidden_size3=self.hidden_size3,
learning_rate=self.learning_rate)
self.memory = Memory(max_size=self.memory_size)
self.s = interface_to_states()
self.rules = Rules()
self.reward_scale = 210 # lost solo schneider schwarz
def clean_rules(i_grammar):
rules = i_grammar.rules
print(rules.get_length(), "rules before")
non_terminals = rules.getNonTerminalsList()
prev_size = -1
while len(non_terminals) != prev_size:
prev_size = len(non_terminals)
counter = Counter(non_terminals)
to_remove = set()
for key in counter:
if counter[key] == 1 and key != "S":
to_remove.add(key)
new_rules = []
for rule in rules.getRules():
nts = rule.getNonTerminals()
if any([nt in to_remove for nt in nts]):
continue
new_rules.append(rule)
for rules_temp in rules.getConsommationRules().values():
for rule in rules_temp:
nts = rule.getNonTerminals()
if any([nt in to_remove for nt in nts]):
continue
new_rules.append(rule)
rules = Rules(new_rules)
non_terminals = rules.getNonTerminalsList()
print(rules.get_length(), "rules after")
return IndexedGrammar(rules)
def get_ISWC_grammar(relations, query):
rules = []
rules.append(EndRule("T", "epsilon"))
rules.append(ProductionRule("S", "Finit", "end"))
rules.append(ProductionRule("Finit", "F", query))
for relation in relations:
rules.append(DuplicationRule("F", relation, "F" + relation))
rules.append(EndRule(relation, relation))
rules.append(ProductionRule("F" + relation, "F", relation))
rules.append(ConsommationRule(relation, "B", "Btemp" + relation))
rules.append(DuplicationRule("Btemp" + relation,
"Lleft" + relation,
"B"))
rules.append(DuplicationRule("Lleft", "L" + relation, relation))
rules.append(ProductionRule("L" + relation, "L", relation))
rules.append(ConsommationRule(relation, "L", "Ltemp" + relation))
rules.append(DuplicationRule("Ltemp" + relation,
"Lleft" + relation,
"Lright" + relation))
rules.append(DuplicationRule("Lleft" + relation,
inverse(relation),
"L"))
rules.append(DuplicationRule("Lright" + relation,
relation,
"L" + relation))
rules.append(EndRule("L", "epsilon"))
rules.append(ConsommationRule("end", "B", "T"))
rules.append(DuplicationRule("F", "B", "T"))
rules = Rules(rules)
return IndexedGrammar(rules)
def __init__(self):
"""
init method
:return: None
"""
self.r = Rules('domain')
self.create_file()
def __init__(self, parent=None):
super(DeveloperInterface, self).__init__(parent)
self.memRules = Rules("rulelist.json")
self.variables = WorkMemory()
self.inst_lbl = QLabel(
"Escribe una sentencia antecedente->consecuente")
self.id_lbl = QLabel("Id:")
self.val_lbl = QLabel("Value:")
self.solv_lbl = QLabel("No se ha llegado a una solucion")
self.st_edit = QLineEdit()
self.var_edit = QLineEdit()
self.values = QComboBox()
self.values.addItem("T")
self.values.addItem("F")
self.refresh_button = QPushButton("Evaluate!")
self.propagate_button = QPushButton("Propagate!")
self.statements = QPlainTextEdit()
self.rules = QPlainTextEdit()
self.solutions = QPlainTextEdit()
self.statements.setReadOnly(True)
self.rules.setReadOnly(True)
self.solutions = QPlainTextEdit()
self.hlayout = QHBoxLayout()
self.hlayout.addWidget(self.st_edit)
self.hlayout.addWidget(self.refresh_button)
self.hlayout2 = QHBoxLayout()
self.hlayout2.addWidget(self.id_lbl)
self.hlayout2.addWidget(self.var_edit)
self.hlayout2.addWidget(self.val_lbl)
self.hlayout2.addWidget(self.values)
self.hlayout2.addWidget(self.propagate_button)
self.main_layout = QGridLayout()
self.main_layout.addWidget(self.inst_lbl, 0, 0)
self.main_layout.addLayout(self.hlayout, 1, 0)
self.main_layout.addWidget(self.statements, 2, 0)
self.main_layout.addLayout(self.hlayout2, 3, 0)
self.main_layout.addWidget(self.rules, 4, 0)
self.main_layout.addWidget(self.solv_lbl, 5, 0)
self.main_layout.addWidget(self.solutions, 6, 0)
self.refresh_button.clicked.connect(self.Evaluate)
self.propagate_button.clicked.connect(self.Propagation)
self.st_edit.setText("((a ^ b) ^ c) -> d")
self.setLayout(self.main_layout)
self.setWindowTitle("My first expert system")
self.UpdateCache()
self.PrintWorkMemory()
def __init__(self, rules=None, *args, **kwargs):
UniTable.__init__(self, *args, **kwargs)
if not isinstance(rules, Rules):
rules = Rules(rules)
self._rules = rules
self._rulearg = self.as_mapping()
self._made = {}
self._inprog = []
def test_calctime300():
r = Rules("data/rules.txt")
assert r.calc_time(0, 300) == (0, 60)
assert r.calc_time(200, 300) == (353, 800)
assert r.calc_time(220, 300) == (390, 880)
assert r.calc_time(250, 300) == (447, 1000)
assert r.calc_time(300, 300) == (540, 1200)
assert r.calc_time(330, 300) == (540, 1200)
def test_calctime200():
r = Rules("data/rules.txt")
assert r.calc_time(0, 200) == (0, 60)
assert r.calc_time(100, 200) == (176, 400)
assert r.calc_time(150, 200) == (265, 600)
assert r.calc_time(200, 200) == (353, 810)
assert r.calc_time(220, 200) == (353, 810)
def deleteRule(rule):
try:
obj = Rules(ruleName=rule)
response = jsonify({"Response": obj.delete()})
return response
except Exception as e:
response = jsonify({"Response": False, "Reason": f"{e}"})
return response
def __init__(self, size, board, tree, network):
self.network = network
self.size = size
self.tree = tree
self.orig = board
self.rules = Rules(size, FLAGS.connections)
self.nr_moves = 0
self.reinitialize()
