def __init__(self, argv:[str]):
trace(0, argv)
self.args = CommandLineParser(argv)
self.mxver = int(self.args.get_arg('mxver', '0'))
if self.mxver == 6:
self.help_file = 'trace-help.output'
self.display_file = 'trace-display.output'
self.print_file = 'trace-print-6x.output'
elif self.mxver == 7:
self.help_file = 'trace-help-7.x.output'
self.display_file = 'trace-display-7.x.output'
self.print_file = 'trace-print-6x.output' # TODO, change to 7
else:
raise ValueError("Unknown MX-One version " + str(self.mxver))
display_args = self.args.display
print_args = self.args.print_args
if self.args.help:
self.print_help()
elif not display_args is None:
self.print_display()
elif not print_args is None:
self.print_print(print_args)
else:
print_str("args: " + " ".join(sys.argv[1:]))
pass
def __init__(self, argv: [str], settings: 'Settings' = None) -> None:
self.command_line = CommandLineParser(argv)
self.settings = settings or Main.find_settings(
self.command_line.settings_file)
# No type hints on variables, as py3to2 doesn't handle them
#self.parsed_display = ParseDisplayOutput(io.StringIO(''))
self.parsed_display = None
self.command_generator = None
def test_remove_arg(self):
argv = [u'progname', u'-hej', u'hopp', u'-alone', u'--bara', u'bra', u'-flera', u'arg', u'till', u'denna']
r = CommandLineParser(argv)
self.assertIn(u'-hej', r.argv)
self.assertIn(u'hopp', r.argv)
r_no_hej = r.remove_arg(u'hej')
self.assertNotIn(u'-hej', r_no_hej.argv)
self.assertNotIn(u'hopp', r_no_hej.argv)
def __init__(self,
program_name,
argv: [str],
settings: 'Settings' = None) -> None:
self.command_line = CommandLineParser(program_name, argv)
self.settings = settings or Main.find_settings(
self.command_line.settings_file)
self.parsed_display = ParseDisplayOutput("")
self.command_generator = CommandGenerator(self.parsed_display,
self.settings)
def test_find_arg(self):
argv = [u'progname', u'-hej', u'hopp', u'-alone', u'--bara', u'bra', u'-flera', u'arg', u'till', u'denna']
r = CommandLineParser.find_arg_index(u'finns_Ej', argv)
self.assertEqual((-1,-1, None), r)
r = CommandLineParser.find_arg_index(u'HEJ', argv)
self.assertEqual((1,2, [u'hopp']), r)
r = CommandLineParser.find_arg_index(u'flera', argv)
self.assertEqual((6, 9, [u'arg', u'till', u'denna']), r)
cmd = CommandLineParser(argv)
self.assertEqual(u'hopp', cmd.get_arg(u'hej'))
self.assertEqual([u'arg', u'till', u'denna'], cmd.get_args(u'flera'))
self.assertEqual(u'arg', cmd.get_arg(u'flera'))
open_ssl.encrypt_file(key, bytes(iv, 'utf-8'), file_to_encrypt,
encrypted_path)
decrypted_path = file_to_encrypt.replace('.py', '.dec')
open_ssl.decrypt_file(key, bytes(iv, 'utf-8'), encrypted_path,
decrypted_path)
with open(file_to_encrypt, 'rb') as original:
with open(decrypted_path, 'rb') as decrypted:
assert original.read() == decrypted.read()
os.remove(decrypted_path)
os.remove(encrypted_path)
print('Test for {} passed'.format(mode))
if __name__ == '__main__':
command_line_parser = CommandLineParser()
parsed_args = command_line_parser.parse_arguments(sys.argv[1:])
enc_type = 'cbc'
openssl = OpenSSL(enc_type)
iv = '0' * 16
iv2 = increment_iv(iv)
ks = jks.KeyStore.load(parsed_args['keystore_path'],
parsed_args['password'])
key = ks.private_keys['self signed cert'].pkey[:32]
msg_list = ['lubie placki bar', 'pala lufa jedyna']
msg_list = [x[:16] for x in msg_list]
rand = randint(0, 1)
random_msg = msg_list[rand]
def replace_arg(self, name, val):
return CommandLineParser(*CommandLineParser.replace_argument(name, self.argv, val))
def set_program_name(self, new_name):
return CommandLineParser(new_name, self.argv)
class TraceMockup:
def __init__(self, argv:[str]):
trace(0, argv)
self.args = CommandLineParser(argv)
self.mxver = int(self.args.get_arg('mxver', '0'))
if self.mxver == 6:
self.help_file = 'trace-help.output'
self.display_file = 'trace-display.output'
self.print_file = 'trace-print-6x.output'
elif self.mxver == 7:
self.help_file = 'trace-help-7.x.output'
self.display_file = 'trace-display-7.x.output'
self.print_file = 'trace-print-6x.output' # TODO, change to 7
else:
raise ValueError("Unknown MX-One version " + str(self.mxver))
display_args = self.args.display
print_args = self.args.print_args
if self.args.help:
self.print_help()
elif not display_args is None:
self.print_display()
elif not print_args is None:
self.print_print(print_args)
else:
print_str("args: " + " ".join(sys.argv[1:]))
pass
def print_help(self):
sys.stdout.write(self.readfile(self.help_file))
def print_display(self):
disp_str = self.readfile(self.display_file)
cc = self.args.get_arg('call-count', 0)
if int(cc) < 3:
sys.stdout.write(disp_str)
return disp_str
# add MADEUP as extra module
key = 'State: idle/free'
has_found = False
for line in disp_str.splitlines():
if not has_found and line.endswith(key):
print_str(line[:len(line)-len(key)] + 'State: stopped , Stored: 75, Size per lim: 5000')
print_str(' First: 2019-01-22 16:16:01 (CET) Last: 2019-01-22 16:16:19 (CET)')
print_str(' Type : unit-trace , Rotating: on , Textlevel: normal')
print_str(' Lim no : 1, Unit no: 4711, Unit name: MADEUP')
print_str(' Time mark: 2019-01-22 16:16:32 (CET), by user: mxone_admin')
print_str(' Trace stopped by : command (manually stopped)')
has_found = True
else:
print_str(line)
def readfile(self, file:str) -> str:
try:
with open(file, 'r', encoding='iso-8859-1') as f:
return str(f.read())
except IOError:
pass
with open(os.path.join("tests", file), 'r', encoding='iso-8859-1') as f:
return str(f.read())
def print_print(self, arg:str) -> str:
n = -1
try:
n = int(arg)
except:
raise ValueError("Should print individ-id: '" + arg + "'")
disp_str = self.readfile(self.print_file)
unit_name = ''
if n == 1:
unit_name = 'SIPLP' # don't change
elif n == 3: # CMP
unit_name = 'CMP'
elif n == 4: # RMP
unit_name = 'RMP'
else:
raise ValueError("trace-mockup can only print 1-SIPLP/3:CMP/4:RMP")
ouput = disp_str.replace(' Trace ind: 1', ' Trace ind: ' + str(n))
ouput = ouput.replace(' Unit name: SIPLP', ' Unit name: ' + unit_name)
sys.stdout.write(ouput)
return ouput
def parse_command_line(self, argv:[str]) -> None:
self.args = {}
i=1
while i < len(argv):
if argv[i][0] == "-":
arg = argv[i].lstrip("-").rstrip().lower()
val = None
i=i+1
if i < len(argv) and argv[i][0] != "-":
val = argv[i]
i = i + 1
self.args[arg] = val
class Main:
help_str = \
"""
trace-helper, can call and group calls to MX-trace.
If starting something not yet defined, it is auto-defined.
Possible to start/stop/print on name, not only ID.
Possible to configure groups if units, all listening to the same name
Switches not used by this program should be passed down to trace
Many settings have default values, change ~/.mx-trace.json
-display_settings to output current settings-file
-gangs Prints which gangs are defined
-add indivuduals_or_gang (same as -unit in trace)
-remove indivuduals_or_gang
-start indivuduals_or_gang
-stop indivuduals_or_gang
-clear indivuduals_or_gang
-print indivuduals_or_gang
-save indivudual_or_gang -prefix trace -postfix log
Print all the individuals to separate files, with specified prefix/postfix. (Prefix might include paths)
-zip output_file.zip indivudual_or_gang
Like save, but generate 1 zip file with all traces
If specifying many individuals/gangs, separate with space
"""
def __init__(self,
program_name,
argv: [str],
settings: 'Settings' = None) -> None:
self.command_line = CommandLineParser(program_name, argv)
self.settings = settings or Main.find_settings(
self.command_line.settings_file)
self.parsed_display = ParseDisplayOutput("")
self.command_generator = CommandGenerator(self.parsed_display,
self.settings)
def set_parsed_display(self, val: ParseDisplayOutput):
self.parsed_display = val
self.command_generator = CommandGenerator(val, self.settings)
def execute(self, args: [str]) -> 'Executor':
return Executor(self.settings.trace_cmd,
self.settings.trace_args + args,
trace_cmd_level=self.settings.debug_trace_commands)
def execute_all(self, list_of_args: [[str]]) -> str:
if not isinstance(list_of_args, list):
raise ValueError(
"args should be list of command-line-lists, was just " +
str(type(list_of_args)))
if not isinstance(list_of_args[0], list):
raise ValueError(
"args should be list of command-line-lists, was just " +
str(type(list_of_args)))
return "\n".join(
[self.execute(arg).str_result for arg in list_of_args])
@staticmethod
def find_settings(file: str = None) -> str:
ex = None
files = [
file,
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'settings.json'),
os.path.join(os.path.expanduser("~"), '.mx-trace',
'settings.json'),
os.path.join(os.path.expanduser("~"), '.mx-trace.json')
]
for f in files:
if not f is None and os.path.exists(f):
try:
return Settings(f)
except BaseException as ex:
trace(
3, "Failed to open settings from " + f + ": " +
str(ex))
trace(
3, "Failed to open settings from any known file " + "\n " +
"\n ".join(files))
return Settings("{\n}") # Return empty settings
def main(self) -> str:
trace(
7, "main method: " + self.command_line.program_name +
" args: [ " + ", ".join(self.command_line.argv) + " ]")
display_settings = self.command_line.display_settings
if display_settings:
return self.call_display_settings()
if self.command_line.gangs_request:
return self.call_display_gangs()
help_args = self.command_line.help
if help_args:
return self.call_help()
display_args = self.command_line.display
if not display_args is None:
trace(3, "display " + " ".join(display_args), file=sys.stderr)
self.call_display(display_args +
self.command_line.display_extra_args().argv)
print(self.parsed_display)
return
add_args = self.command_line.add
if not add_args is None:
trace(3, "add " + " ".join(add_args))
self.call_display()
add_extra_args = self.command_line.add_extra_args().argv
self.call_add(
add_args.split(','), self.command_line.lim,
self.command_line.textlevel
or self.settings.default_textlevel, add_extra_args)
return
remove_args = self.command_line.remove
if not remove_args is None:
trace(3, "remove " + " ".join(remove_args))
self.call_display()
remove_extra_args = self.command_line.remove_extra_args().argv
self.call_remove(remove_args.split(','), remove_extra_args)
return
start_args = self.command_line.start
if not start_args is None:
trace(3, "start " + " ".join(start_args))
self.call_display()
start_extra_args = self.command_line.start_extra_args().argv
self.call_start(
start_args.split(','), self.command_line.lim,
self.command_line.textlevel
or self.settings.default_textlevel, start_extra_args)
return
stop_args = self.command_line.stop
if not stop_args is None:
trace(3, "stop " + " ".join(stop_args))
self.call_display()
self.call_stop(stop_args.split(','),
self.command_line.stop_extra_args().argv)
return
print_args = self.command_line.print_args
if not print_args is None:
trace(3, "print " + print_args)
self.call_display()
extra_args = self.command_line.print_extra_args().argv
printout = self.call_print([print_args], extra_args)
print(printout)
return printout
save_args = self.command_line.save
if not save_args is None:
prefix = self.command_line.file_prefix or self.settings.file_prefix
postfix = self.command_line.file_postfix or self.settings.file_postfix
trace(3, "save " + save_args, ", prefix=", prefix,
", postfix=", postfix)
self.call_display()
self.call_save(save_args.split(','), prefix, postfix)
return
zip_args = self.command_line.zip
if not zip_args is None:
prefix = self.command_line.file_prefix or self.settings.zip_prefix
postfix = self.command_line.file_postfix or self.settings.zip_postfix
zip_file = zip_args[0]
_ignored, file_extension = os.path.splitext(zip_file)
if len(file_extension) == 0:
zip_file = zip_file.rstrip('.') + '.zip'
individuals = zip_args[1:]
trace(3, "zip ", individuals, " to ", zip_file, ", prefix=",
prefix, ", postfix=", postfix)
self.call_display()
self.call_zip(individuals, zip_file, prefix, postfix)
return
trace(
2,
'Unknown command, calling trace verbatim for all individuals')
self.call_display()
self.call_unknown_command()
return
def expand_to_ids(self, ids_or_gangs: [str]) -> str:
if isinstance(ids_or_gangs, str): # Handle if list forgotten
ids_or_gangs = [ids_or_gangs]
list_of_lists = [iog.split(',') for iog in ids_or_gangs]
ids_or_gangs = [
val for sublist in list_of_lists for val in sublist
]
if len(ids_or_gangs) == 0 or ids_or_gangs[0].lower() == 'all':
return [str(indv) for indv in self.parsed_display.individuals]
else:
return self.settings.expand_to_ids(ids_or_gangs)
def get_existing_ids(self, id_names: [str]) -> [str]:
return map(lambda indv: indv.id,
self.get_existing_indivuduals(id_names))
# if len(id_names) == 0 or id_names[0].lower() == 'all':
# id_names = [str(indv) for indv in self.parsed_display.individuals]
# else:
# id_names = self.settings.expand_to_ids(id_names)
# return list(filter(lambda id: not self.parsed_display.get_individual(id) is None, id_names))
def get_existing_indivuduals(
self, id_names: [str]) -> ['ParseDisplayOutput.Individual']:
if len(id_names) == 0 or id_names[0].lower() == 'all':
id_names = [
str(indv) for indv in self.parsed_display.individuals
]
else:
id_names = self.settings.expand_to_ids(id_names)
individuals = map(
lambda id: self.parsed_display.get_individual(id), id_names)
return [x for x in individuals if x is not None]
#return list(filter(lambda indv: not self.parsed_display.get_individual(id) is None, id_names))
def get_non_existing_individuals(self, id_names: [str]) -> [str]:
if len(id_names) == 0 or id_names[0].lower() == 'all':
id_names = [
str(indv) for indv in self.parsed_display.individuals
]
else:
id_names = self.settings.expand_to_ids(id_names)
return list(
filter(
lambda id: self.parsed_display.get_individual(id) is None,
id_names))
def ensure_individuals_exists(self, id_names: [str], lim: str,
textlevel: str, extra_args: [str]):
self.add_individuals(self.get_non_existing_individuals(id_names),
lim, textlevel, extra_args)
def call_display_gangs(self) -> str:
res = "\n".join([(g['name'] + ": " + ", ".join(g['members']))
for g in self.settings.gangs])
print(res)
return res
def call_display_settings(self) -> str:
print(self.settings.raw_data)
return self.settings.raw_data
def call_help(self) -> str:
print(Main.help_str)
return Main.help_str
def call_display(self, args: [str] = []) -> 'ParseDisplayOutput':
disp_output = self.execute(['-display'] + args).str_result
self.set_parsed_display(ParseDisplayOutput(disp_output))
def add_individuals(self, individuals: [str], lim: str, textlevel: str,
extra_args: [str]):
trace(4, "Adding individuals ", individuals)
self.execute_all(
self.command_generator.add_indv(individuals, lim, extra_args))
self.call_display()
for id in individuals:
indv = self.parsed_display.get_individual(id)
if indv is None:
trace(2, 'Failed to create induvidual ' + id)
sys.exit(17)
if indv.textlevel != textlevel:
self.execute_all(
self.command_generator.set_textlevel(id, textlevel))
def call_add(self,
args: [str],
lim: str,
textlevel: str,
extra_args: [str] = []):
if self.parsed_display is None:
raise ValueError("Called start when no display parser yet!")
individuals = self.expand_to_ids(args)
self.ensure_individuals_exists(individuals, lim, textlevel,
extra_args)
def call_remove(self, args: [str], extra_args: [str] = []):
if self.parsed_display is None:
raise ValueError("Called start when no display parser yet!")
existing = self.get_existing_ids(self.expand_to_ids(args))
remove_cmds = self.command_generator.remove(existing)
for indv_stop in remove_cmds:
self.execute(indv_stop + extra_args)
def call_start(self,
args: [str],
lim: str,
textlevel: str,
extra_args: [str] = []):
self.call_add(args, lim, textlevel)
individuals = self.expand_to_ids(args)
start_cmds = self.command_generator.start(individuals)
for indv_start in start_cmds:
self.execute(indv_start + extra_args)
def call_stop(self, args: [str], extra_args: [str] = []):
if self.parsed_display is None:
raise ValueError("Called stop when no display parser yet!")
individuals = self.expand_to_ids(args)
existing = self.get_existing_ids(individuals)
stop_cmds = self.command_generator.stop(existing)
for indv_stop in stop_cmds:
self.execute(indv_stop + extra_args)
def call_print(self, args: [str], extra_args: [str] = []) -> str:
if self.parsed_display is None:
raise ValueError("Called print when no display parser yet!")
individuals = self.expand_to_ids(args)
existing = filter(
lambda id: not self.parsed_display.get_individual(id) is None,
individuals)
print_cmds = self.command_generator.print_cmd(existing)
return self.execute_all(print_cmds + extra_args)
def call_save(self,
args: [str],
prefix,
postfix,
extra_args: [str] = []) -> str:
if self.parsed_display is None:
raise ValueError("Called print when no display parser yet!")
individuals_names = self.expand_to_ids(args)
individuals = map(
lambda id: self.parsed_display.get_individual(id),
individuals_names)
existing_individuals = self.get_existing_ids(individuals)
# extra_args = self.command_line.get_non_save()
for indv in existing_individuals:
(print_cmd,
filename) = self.command_generator.save_cmd([indv.unit_name],
prefix,
postfix)[0]
trace(
3, 'printing ' + indv.id + "/" + indv.unit_name + " to " +
filename)
ex = self.execute(print_cmd)
with io.open(filename, "w", encoding="latin-1") as fil:
fil.write(ex.str_result + extra_args)
def call_zip(self,
args: [str],
zipfilename,
prefix,
postfix,
extra_args: [str] = []) -> str:
if not isinstance(args, list):
raise ValueError('Should be called with list of individuals')
if self.parsed_display is None:
raise ValueError("Called print when no display parser yet!")
individuals_names = self.expand_to_ids(args)
existing_individuals = self.get_existing_indivuduals(
individuals_names)
# extra_args = self.command_line.get_non_zip()
with zipfile.ZipFile(zipfilename, "w") as z:
for indv in existing_individuals:
(print_cmd, filename) = self.command_generator.save_cmd(
[indv.unit_name], prefix, postfix)[0]
trace(
3, 'printing ' + indv.id + "/" + indv.unit_name +
" to " + filename)
ex = self.execute(print_cmd)
z.writestr(filename, ex.result)
trace(5, "Wrote to " + zipfilename)
try:
trace(5, "Size became " + str(os.path.getsize(zipfilename)))
except:
trace(1, "Failed to save data to " + zipfilename)
def expand_first_gang_in_commandline(self, args):
for i, a in enumerate(args):
expanded = self.expand_to_ids(a)
if len(expanded) > 1:
pre = args[:i] if i > 0 else []
post = args[i + 1:] if i + 1 < len(args) else []
return [pre + [indv] + post for indv in expanded]
return [args]
def call_unknown_command(self):
def find_gang() -> (int, [str]):
for i, a in enumerate(self.command_line.argv[1:]):
gang = self.expand_to_ids(a)
if len(gang) > 0:
pre = self.command_line.argv[:i] if i > 0 else []
post = self.command_line.argv[i + 1:] if i + 1 < len(
self.command_line.argv) else []
return [pre + [indv] + post for indv in gang]
return None
gang_expanded = find_gang() or self.command_line.argv[1:]
for a in gang_expanded:
trace(4, a)
self.execute(a)
def replace_arg(self, name: str, val: [str]) -> 'CommandLineParser':
return CommandLineParser(
*CommandLineParser.replace_argument(name, self.argv, val))
def main():
"""最初に実行する主な関数だと思ってくれだぜ☆（＾～＾）"""
# 説明を出そうぜ☆（＾～＾）
log = Log()
log.clear()
# 最初は全部のコマンドを実装できないが、だんだん増やしていけだぜ☆（＾～＾）
log.println("""きふわらべの〇×ゲーム
コマンド:
`do 7` - 手番のプレイヤーが、 7 番地に印を付けます。
`go` - コンピューターが次の1手を示します。
`info-off` - info出力なし。
`info-on` - info出力あり(既定)。
`pos` - 局面表示。
`position xfen 3/3/3 o moves 5 1 2 8 4 6 3 7 9` - 初期局面と棋譜を入力。
`undo` - 1手戻します。
`uxi` - 'uxiok tic-tac-toe {protocol-version}' を返します。
`xfen` - 現局面のxfen文字列表示。
""")
# 初期局面
pos = Position()
# info_enable は 'computer_player.py' を実装してから、ここに追加しろだぜ☆（＾～＾）
info_enable = True
# [Ctrl]+[C] でループを終了
while True:
# まず最初に、コマンドライン入力を待機しろだぜ☆（＾～＾）
line = input()
# コマンドライン☆（＾～＾） p は parser の意味で使ってるぜ☆（＾～＾）
p = CommandLineParser(line)
# 本当は よく使うコマンド順に並べた方が高速だが、先に見つけた方が選ばれるので後ろの方を漏らしやすくて むずかしいし、
# だから、アルファベット順に並べた方が見やすいぜ☆（＾～＾）
if p.starts_with('do'):
p.go_next_to('do ')
if p.rest != '':
UxiProtocol.do(pos, p.rest, log)
# go は 'computer_player.py' を実装してから、ここに追加しろだぜ☆（＾～＾）
elif p.starts_with("go"):
search = Search(pos.friend, pos.pieces_num, info_enable)
(addr, result) = SearchComputer.go(pos, search, log)
if addr is not None:
log.println(
f'info result={result} nps={SearchPerformance.nps(search)}'
)
log.println(f'bestmove {addr}')
else:
log.println('resign')
# info-off は 'computer_player.py' を実装してから、ここに追加しろだぜ☆（＾～＾）
elif p.starts_with('info-off'):
info_enable = False
# info-on は 'computer_player.py' を実装してから、ここに追加しろだぜ☆（＾～＾）
elif p.starts_with('info-on'):
info_enable = True
elif p.starts_with('position'):
p.go_next_to('position ')
if p.rest != '':
pos = UxiProtocol.from_xfen(p.rest, log)
elif p.starts_with('pos'):
log.println(pos.pos())
elif p.starts_with('quit'):
return
elif p.starts_with('undo'):
UxiProtocol.undo(pos)
elif p.starts_with('uxi'):
log.println('uxiok tic-tac-toe v20200704.0.0')
elif p.starts_with('xfen'):
log.println(UxiProtocol.to_xfen(pos))
else:
log.println(f'Debug | Invalid command=|{p.rest}|')
# +---+---+---+
PositionHelper.undo_move(pos)
log.println(pos.pos())
# [Next 1 move(s) | Go o]
#
# +---+---+---+
# | | | | マスを選んでください。例 `do 7`
# +---+---+---+
# | | | | 7 8 9
# +---+---+---+ 4 5 6
# | | | | 1 2 3
# +---+---+---+
log.println(f'opponent={PositionHelper.opponent(pos)}')
# Step 4.
p = CommandLineParser('Go to the Moon!')
log.println(f"Go to=|{p.starts_with('Go to')}|")
# Go to =|True|
log.println(f"Goto =|{p.starts_with('Goto')}|")
# Goto =|False|
log.println(f'p.starts=|{p.starts}|')
# p.starts=|0|
log.println(f'p.rest=|{p.rest}|')
# p.rest =|Go to the Moon!|
p.go_next_to('Go to')
log.println(f'p.starts=|{p.starts}|')
# p.starts=|5|
log.println(f'p.rest=|{p.rest}|')
# p.rest =| the Moon!|
# Step 5.
