def main():
parser = argparse.ArgumentParser()
parser.add_argument("--xml",
type=str,
help="Location of timetable xml file",
required=False)
parser.add_argument("--begin",
type=str,
help="Semester beginning date",
required=True)
parser.add_argument("--end",
type=str,
help="Semester ending date",
required=True)
args = parser.parse_args()
xml = ""
if (args.xml):
xml = args.xml
else:
username = input('에브리타임 아이디 : ')
password = getpass.getpass()
year = input('가져올 년도 : ')
semester = input('가져올 학기 : ')
e = everytime.Everytime(username, password)
xml = e.get_timetable(year, semester)
c = Convert(xml)
c.get_calendar(c.get_subjects(), args.begin, args.end)
def test_json_to_player(self):
self.assertTrue(Convert.json_to_player(self.jPlayer_1), self.player_1)
self.assertNotEqual(Convert.json_to_player(self.jPlayer_1),
self.player_2)
self.jPlayer_1[0][1] = -1
self.assertRaises(AssertionError, Convert.json_to_player,
self.jPlayer_1)
def new_post():
key = request.forms.get('key')
if not key_verified(key):
return 'Verify Failured, Key Error!\n'
filename = request.forms.get('filename')
content = request.forms.get('content')
filename = os.path.basename(filename)
title, ext = os.path.splitext(filename)
ext = ext.lstrip('.')
try:
tags_str, content = content.split('\n', 1)
tags_str = tags_str.split(':')[-1]
tags = [t.strip() for t in tags_str.split(',')]
except:
return 'Invalid content!\n'
try:
c = Convert(ext)
except NotImplementedError:
return 'This format not supported yet!\n'
except Exception:
return 'Error occurred!\n'
try:
html = c.convert(content)
except ClassNotFound, e:
return 'ClassNotFound, %s\n' % str(e)
def test_json_to_player(self):
self.assertTrue(self.player_soft_eq(Convert.json_to_player(self.jPlayer_1), self.player_1))
self.assertTrue(self.player_soft_eq(Convert.json_to_player(self.jPlayer_2), self.player_2))
self.assertTrue(self.player_soft_eq(Convert.json_to_player(self.jPlayer_3), self.player_3))
self.assertFalse(self.player_soft_eq(Convert.json_to_player(self.jPlayer_1), self.player_2))
self.jPlayer_1[0][1] = -1
self.assertRaises(AssertionError, Convert.json_to_player, self.jPlayer_1)
def operations_type2_n(self,operator,n1):
operation_code = self.operations[operator]
c = Convert()
n1 = c.decimal_to_hexadecimal(n1)
n1 = n1[:-1]
del c
return operation_code + str(n1) + "0"
def is_type_c(self,desp):
c = Convert()
desp = c.to_decimal(desp)
del c
if desp < 4096:
return True
return False
def test_player_to_json(self):
self.assertEqual(Convert.player_to_json(self.player_1), self.jPlayer_1)
self.assertNotEqual(Convert.player_to_json(self.player_1),
self.jPlayer_2)
self.player_1.food_bag = -1
self.assertRaises(AssertionError, Convert.player_to_json,
self.player_1)
def new_post():
key = request.forms.get("key")
if not key_verified(key):
return "Verify Failured, Key Error!\n"
filename = request.forms.get("filename")
content = request.forms.get("content")
filename = os.path.basename(filename)
title, ext = os.path.splitext(filename)
ext = ext.lstrip(".")
try:
tags_str, content = content.split("\n", 1)
tags_str = tags_str.split(":")[-1]
tags = [t.strip() for t in tags_str.split(",")]
except:
return "Invalid content!\n"
try:
c = Convert(ext)
except NotImplementedError:
return "This format not supported yet!\n"
except Exception:
return "Error occurred!\n"
try:
html = c.convert(content)
except ClassNotFound, e:
return "ClassNotFound, %s\n" % str(e)
def __init__(self):
self.index = 0
self.list_n = []
self.conv = Convert()
self.reg = Register("X")
self.hexa = Hexadecimal()
self.last_code = 0
def test_json_to_player(self):
self.assertEqual(Convert.json_to_player(self.jPlayer_1), self.player_1)
self.assertEqual(Convert.json_to_player(self.jPlayer_2), self.player_2)
self.assertEqual(Convert.json_to_player(self.jPlayer_3), self.player_3)
self.assertNotEqual(Convert.json_to_player(self.jPlayer_1), self.player_2)
self.jPlayer_1[0][1] = -1
self.assertRaises(AssertionError, Convert.json_to_player, self.jPlayer_1)
def decode(self, msg):
"""
Decides which type of message the server has sent and verifies that the
timing of the message is valid and communicates to the player if the
message is valid.
:param msg: the message from the server to decode.
:return: the message to send to the Dealer, if any.
"""
if msg == "ok":
return
if "feeding" in possible_next_states[self.state] and len(msg) == 5:
player = Convert.json_to_player_state(msg[0:3])
opponents = Convert.json_to_listof_listof_species(msg[4])
feeding = self.player.next_feeding(player, msg[3], opponents)
self.state = "feeding"
return Convert.feeding_to_json(feeding)
(player, wh) = self.decode_start(msg)
if player and "start" in possible_next_states[self.state]:
print("Got start message")
self.player.start(player, wh)
self.state = "start"
return
decode_choose = self.decode_choose(msg)
if decode_choose and "choose" in possible_next_states[self.state]:
print("Choosing action")
choice = self.player.choose(decode_choose)
self.state = "choose"
return Convert.action_to_json(choice)
raise Exception
def minus_than(self,num1,num2):
convert = Convert()
num1 = self.change_hexadecimal(num1)
num2 = self.change_hexadecimal(num2)
num1 = convert.to_decimal(num1)
num2 = convert.to_decimal(num2)
del convert
return num1<num2
def test_species_to_json(self):
self.assertEqual(Convert.species_to_json(self.species_1),
self.jSpecies_1)
self.assertNotEqual(Convert.species_to_json(self.species_1),
self.jSpecies_2)
self.species_1.population = -1
self.assertRaises(AssertionError, Convert.species_to_json,
self.species_1)
def get_binary_code(self,operator):
code = self.operations[operator]
c = Convert()
dec_code = c.to_decimal(code+"H")
binary = c.decimal_to_binary(int(dec_code),8)
binary = binary[0:-2]
del c
return binary
def relative_base(self,arg):
hex = Hexadecimal()
c = Convert()
res = hex.subs(arg,self.base)
res_dec = c.to_decimal(res)
if res_dec >= 0 and res_dec <= 4095:
return res
return None
def greenButtonClicked(self):
"""
This function is called when the Make Blue button is pressed in the
application to then call the convert_image_to_xxx method.
"""
img = Convert(Image.open('original.jpg'))
img.convert_image_to_green()
self.display_saved()
def test_json_to_trait(self):
self.assertEqual(
Convert.json_to_trait(self.jt_1).convert_to_json(), self.jt_1)
self.assertNotEqual(
Convert.json_to_trait(self.jt_1).convert_to_json(), self.jt_2)
self.assertEqual(
Convert.json_to_trait(self.jSpecies_card1).convert_to_json(),
self.jSpecies_card1)
def test_feeding_to_json(self):
self.assertEqual(Convert.feeding_to_json(self.feed_1),
self.json_feed_1)
self.assertEqual(Convert.feeding_to_json(self.feed_2),
self.json_feed_2)
self.assertEqual(Convert.feeding_to_json(self.feed_3),
self.json_feed_3)
self.assertEqual(Convert.feeding_to_json(self.feed_4),
self.json_feed_4)
def operations_type_2_rn(self,operator,r,n):
operation_code = self.operations[operator]
r = self.registers.get(r,"")
c = Convert()
n = c.decimal_to_hexadecimal(n)
n = n[:-1]
del c
obj_code = operation_code + r + str(n)
return obj_code
def test_json_to_species(self):
self.assertTrue(self.species_soft_eq(Convert.json_to_species(self.jSpecies_1),
self.species_1))
self.assertTrue(self.species_soft_eq(Convert.json_to_species(self.jSpecies_2),
self.species_2))
self.assertFalse(self.species_soft_eq(Convert.json_to_species(self.jSpecies_1),
self.species_2))
self.jSpecies_1[0][1] = -1
self.assertRaises(AssertionError, Convert.json_to_species, self.jSpecies_1)
def get_len_program(self):
c = Convert()
x = self.bloques[-1]
ini = self.bloques[0]
val = c.to_decimal(x.get_load_dir())
val_len = c.to_decimal(x.length)
val_ini = c.to_decimal(ini.get_load_dir())
val = val + val_len - val_ini
val = c.decimal_to_hexadecimal(val)
return val
def test_json_to_species(self):
self.assertEqual(Convert.json_to_species(self.jSpecies_1),
self.species_1)
self.assertEqual(Convert.json_to_species(self.jSpecies_2),
self.species_2)
self.assertNotEqual(Convert.json_to_species(self.jSpecies_1),
self.species_2)
self.jSpecies_1[0][1] = -1
self.assertRaises(AssertionError, Convert.json_to_species,
self.jSpecies_1)
def make_T(self):
c = Convert()
dir = self.filter_number(self.init_dir)
dir = self.adjust_bytes(dir,6,False)
len_register = len(self.register)/2
len_hex = c.decimal_to_hexadecimal(len_register)
hex = self.filter_number(len_hex)
hex = self.adjust_bytes(hex,2,False)
register = "T" + dir +hex+self.register
return register
def write(self):
logging.debug("Creating "+self.name+"...")
out = "/*! @file "+os.path.split(self.filename)[1]+" */"
for include in self.includes:
out += "\n"+Convert.include(include)
for namespace in self.namespaces:
out += "\n"+Convert.namespace(namespace)
out += "\n"+self.writeRecursive(None,self.elements)
self.file.write(out)
self.file.close()
def test_json_to_species(self):
self.assertEqual(
Convert.json_to_species(self.jSpecies_1).convert_to_json(),
self.jSpecies_1)
self.assertEqual(
Convert.json_to_species(self.jSpecies_2).convert_to_json(),
self.jSpecies_2)
self.assertNotEqual(
Convert.json_to_species(self.jSpecies_1).convert_to_json(),
self.jSpecies_2)
def div(self,num1,num2):
convert = Convert()
num1 = self.change_hexadecimal(num1)
num2 = self.change_hexadecimal(num2)
num1 = convert.to_decimal(num1)
num2 = convert.to_decimal(num2)
res = int(num1)/int(num2)
res = convert.decimal_to_hexadecimal(res)
del convert
return res
def __init__(self):
self.db = DB()
self.session = self.db.get_session()
self.new_session = self.db.new_session()
# self.st = StanfordCoreNLP('/home/yyao009/stanford-corenlp-full-2016-10-31/')
self.st = StanfordCoreNLPPLUS('http://localhost')
# path = os.path.dirname(__file__)
# file = os.path.join(path, '../data/abbr.txt')
self.convert = Convert()
self.pool = ThreadPool(24)
def directive_word(self,value):
c = Convert()
if not c.is_hexadecimal(value):
value = int(float(value))
value = c.decimal_to_hexadecimal(value)
r = Register("T")
value = r.adjust_bytes(value,6,True)
value = r.filter_number(value)
del r
return value
def __init__(self):
self.table = os.getenv("DB_TABLE")
self.tagging = os.getenv("TAGGING")
self.conn = mysql.connector.connect(host=os.getenv("DB_HOST"),
database=os.getenv("DB_NAME"),
user=os.getenv("DB_USER"),
password=os.getenv("DB_PASS"))
self.convert = Convert()
self.cursor = self.conn.cursor()
def make_M_modificado(self,obj_code,cp_num):
c = Convert()
cp_num = c.to_decimal(cp_num)
cp_num = c.decimal_to_hexadecimal(cp_num)
dir= self.filter_number(cp_num)
dir = self.adjust_bytes(dir,6,False)
edit_bytes = obj_code
len_bytes = len(edit_bytes)
len_bytes = self.adjust_bytes(str(len_bytes),2,False)
register = "M" + str(dir) + str(len_bytes)+"+"+self.name
return register
def get_value_cad_BYTE(self,data):
string_out =""
c = Convert()
r = Register("T")
for caracter in data:
car = str(ord(caracter))
car = c.decimal_to_hexadecimal(car)
car = r.filter_number(car)
string_out+=car
del c
return string_out
def DownCal(begin, end, username, password):
# year = input('가져올 년도 : ')
# semester = input('가져올 학기 : ')
e = everytime.Everytime(username, password)
xml = e.get_timetable(year, semester)
c = Convert(xml)
c.get_calendar(c.get_subjects(), begin, end)
print('test SUCESS')
def plus(self,num1,num2):
convert = Convert()
num1 = self.change_hexadecimal(num1)
num2 = self.change_hexadecimal(num2)
num1 = convert.to_decimal(num1)
num2 = convert.to_decimal(num2)
if not num1 == -1 and not num2 ==-1:
res = num1+num2
res = convert.decimal_to_hexadecimal(res)
return res
else:
return "error"
def __init__(self, window):
self.window = window
self.tabse = Tabse()
self.lonsc = "0H"
self.dirsc = "0H"
self.dirprog = "0H"
self.direj = "0H"
self.hexa = Hexadecimal()
self.convert = Convert()
self.register = Register("A")
self.error_indefinido = False
self.error_duplicado = False
def OFB_test():
mode = Mode()
cb = Convert()
ce = Crypto_Exec(128)
string = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
b = ce.block_split(string)
value = cb.convert_bin(b)
IV = "B" * 16
t = mode.IV_genrate(IV)
encrypto = mode.OFB_mode(value, t)
decrypto = mode.OFB_mode(encrypto, t)
t = cb.convert_str(decrypto)
def test_convert_header(self):
""" take the raw content and add header """
client = Convert()
results = client.convert_item({
"title": "Foo",
"created_at": "2013-04-12",
"body": "### Foo Bar",
"tags": [],
"id": 5
})
assert results is not None
def operation_type_3_4(self,cp,operator,arg,format_type,num_line,dir_type,type_c,is_index,valid_label):
c = Convert()
operator = self.get_binary_code(operator)
flags = self.get_flags(dir_type)
num_max = 3
res = arg
entra = True
if format_type == 4:
flags['e']=1
num_max=5
if not type_c and valid_label == "relativo":
self.m_register.append(num_line)
res = self.current_register.adjust_bytes(arg,num_max,True)
else:
if type_c:
if not self.is_type_c(arg):
entra = True
else:
entra = False
if not c.is_hexadecimal(arg):
arg = c.decimal_to_hexadecimal(arg)
res = self.current_register.adjust_bytes(arg,3,True)
if entra:
res = self.is_relative_cp(cp,arg)
if not res:
res = self.relative_base(arg)
if res:
flags['b'] = 1
else:
res = arg
valid_label = False
else:
flags['p'] = 1
res = self.current_register.adjust_bytes(res,num_max,True)
if is_index:
flags['x'] = 1
if not valid_label:
flags['b'] = 1
flags['p'] = 1
if valid_label == "_":
flags['b'] = 0
flags['p'] = 0
flags = self.flags_string(flags)
val = operator + flags
val = str(int(val,2))
val = c.decimal_to_hexadecimal(val)
if len(val)==3:
val = "0"+val
val = self.current_register.adjust_bytes(val,3,True)
val += str(res)
del c
return val
def get_address_tarjet(self, value):
c = Convert()
addressing = value[0] + "H"
addressing = int(c.to_decimal(addressing))
val = value
bina = c.decimal_to_binary(addressing, 4)
bina = c.mask_and(bina, "1000")
if bina == "1000":
val = self.hex.subs(value, "8000H")
x = self.get_x_value()
val = self.hex.plus(val, x)
val = self.reg.filter_number(val)
return val
def is_relative_cp(self,cp,arg):
hex = Hexadecimal()
c = Convert()
res_hex = hex.subs_minus(arg,cp)
sign = res_hex[1]
res_hex = res_hex[0]
res = int(c.to_decimal(res_hex))
if sign == "-":
res = (res ^ 4095)+1
res = res * -1
if res <= 2047 and res >= -2048:
return c.exp_to_hexadecimal(res)
else:
return None
def test_json_to_dealer(self):
dealer = Convert.json_to_dealer(self.jConfig_1)
self.assertEqual(len(dealer.player_sets), 3)
self.assertEqual(dealer.watering_hole, 42)
self.assertEqual(len(dealer.deck), 2)
self.assertEqual(dealer.deck[0], self.tc_5)
self.assertEqual(dealer.deck[1], self.tc_6)
def charge_text(self):
c = Convert()
for r in self.registers:
string = r[9:]
index = 0
init = r[1:7]
col_start = init[-1] + "H"
col = int(c.to_decimal(col_start) + 1)
res = self.hex.subs(init[:-1], self.init[:-1])
dec_res = int(c.to_decimal(res))
while index < len(string):
byte = string[index : index + 2]
item = QtGui.QTableWidgetItem(byte)
self.window.tableWidget.setItem(dec_res, col, item)
index += 2
col = (col + 1) % 17
if col == 0:
col = 1
dec_res += 1
def append_field(self, k, v):
assert k and isinstance(k, basestring)
if k in self.__kset:
return
k = Convert.bs2utf8(k)
v = Convert.bs2utf8(v)
self.__fields.append('{0}={1}'.format(k, v))
self.__kset.update({k: v})
def charge_header(self):
init = self.header[7:13]
self.init = init
length = self.header[13:]
self.end_program = self.hex.plus(init, length)
star_rows = length[:-1]
index = init[:-1]
num_rows = star_rows + "H"
c = Convert()
num_rows = int(c.to_decimal(num_rows))
self.window.tableWidget.setRowCount(num_rows + 1)
it = 0
while it <= num_rows:
dir = index + "0H"
r = Register("T")
dir = r.adjust_bytes(dir, 6, False)
item = QtGui.QTableWidgetItem(dir)
self.window.tableWidget.setItem(it, 0, item)
it += 1
index = self.hex.plus(index, "1H")[:-1]
def decode_start(self, msg):
"""
Attempts to decode the given msg into a tuple (player, watering_hole)
:param msg: The JSON message to decode.
:return: The tuple (PlayerState, Int) representing the player and the
food in the watering hole, or (False, False) if the conversion fails.
"""
try:
assert(isinstance(msg[0], int))
return (Convert.json_to_player_state(msg[1:]), msg[0])
except Exception:
return (False, False)
def OnDropFiles(self, x, y, folders):
for folder in folders:
xl_list = fileList(folder)
if len(xl_list) != 0:
start_time = time.time()
converter = Convert()
for xl_file in xl_list:
#print "type(xl_list) %s" % type(xl_file)
xl_name = os.path.basename(xl_file) # xl_name is xl_file without its path.
self.window.WriteText('%s' % xl_name + '....')
csv_file = re.sub('.xls[x]?$', '.csv', xl_file)
converter.xlConvert(xl_file, xl_name, csv_file)
#converter.xlConvert()
self.window.WriteText('%s' % 'OK\n')
converter.terminate()
end_time = time.time() - start_time
self.window.WriteText(u'转换完成，用时%r秒!\n' % round(end_time,1))
else:
self.window.WriteText('No excel file in the directory!\n')
def __init__(self,window):
self.window = window
self.tabse = Tabse()
self.lonsc = "0H"
self.dirsc = "0H"
self.dirprog = "0H"
self.direj = "0H"
self.hexa = Hexadecimal()
self.convert = Convert()
self.register = Register("A")
self.error_indefinido = False
self.error_duplicado = False
class TestConvert(unittest.TestCase):
def setUp(self):
self.convert = Convert()
self.validtxt = "juego.txt"
self.invalidtxt = "juego1.txt"
self.validcsv = "juego.csv"
self.invalidcsv = "juego1.csv"
### ******* Unittest for convert class *************
def test_if_txt_file_is_converted_to_string(self):
expected = type(self.validtxt)
self.assertEqual(expected,type(self.convert.txt_file_to_string(self.validtxt)))
def test_if_string_from_txt_file_is_correct_converted(self):
expected = '003020600900305001001806400008102900700000008006708200002609500800203009005010300'
self.assertEqual(expected,self.convert.txt_file_to_string(self.validtxt))
def test_if_txt_file_convert_display_a_friendly_message_for_invalid_input(self):
expected = "Please insert a txt file with the correct dimensions"
self.assertEqual(expected,self.convert.txt_file_to_string(self.invalidtxt))
def test_if_csv_file_is_converted_to_string(self):
expected = type(self.validcsv)
self.assertEqual(expected,type(self.convert.csv_file_to_string(self.validcsv)))
def test_if_string_from_csv_file_is_correct_converted(self):
expected = '003020600900305001001806400008102900700000008006708200002609500800203009005010300'
self.assertEqual(expected,self.convert.csv_file_to_string(self.validcsv))
def test_if_csv_file_convert_display_a_friendly_message_for_invalid_input(self):
expected = "Please insert a csv file with the correct dimensions"
self.assertEqual(expected,self.convert.csv_file_to_string(self.invalidcsv))
def test_json_to_trait_card(self):
self.assertEqual(Convert.json_to_trait_card(self.jtc_1), self.tc_1)
self.assertEqual(Convert.json_to_trait_card(self.jtc_2), self.tc_2)
self.assertEqual(Convert.json_to_trait_card(self.jtc_3), self.tc_3)
self.assertEqual(Convert.json_to_trait_card(self.jtc_4), self.tc_4)
self.assertEqual(Convert.json_to_trait_card(self.jtc_5), self.tc_5)
self.assertEqual(Convert.json_to_trait_card(self.jtc_6), self.tc_6)
def operations_code(self,operator,m,is_index):
r = Register("T")
c = Convert()
op = self.operations[operator]
op = op+"H"
op = c.to_decimal(op)
op = int(op)
binary = c.decimal_to_binary(op,24)
binary = c.shift_binary_left(binary,16)
if is_index:
binary = c.mask_or(binary,"000000001000000000000000")
m = c.to_decimal(m)
m = int(m)
m = c.decimal_to_binary(m,24)
binary = c.mask_or(binary,m)
val = int(binary,2)
val = c.decimal_to_hexadecimal(val)
val = r.filter_number(val)
val = r.adjust_bytes(val,6,False)
del r
del c
return val
