def __init__(self):
self.index = 0
self.list_n = []
self.conv = Convert()
self.reg = Register("X")
self.hexa = Hexadecimal()
self.last_code = 0
def new_post():
key = request.forms.get('key')
if not key_verified(key):
return '<h2>Security Key NOT matched!</h2>'
title = request.forms.get('title').strip()
if not title:
return "<h2>Error: title is empty!</h2>"
tags_str = request.forms.get('tags').strip().strip(",")
if not tags_str:
return "<h2>Error: tag is empty!</h2>"
tags = [t.strip() for t in tags_str.split(',')]
md = request.forms.get('markdown')
if not md:
return "<h2>Error: no contents!</h2>"
code = request.forms.get('code')
html = Convert("md").convert(md)
try:
with session_context() as session:
if not code:
p = store_new_post(session, title, html, md, tags)
else:
p = edit_post(session, code, title, html, md, tags)
except Exception as err:
p = None
msg = str(err)
return template('jump2article', p = p, msg = '' if p else msg)
def main(path):
ImageMatrix = []
# Cleans up export folder and slices the data
Convert('D:\\IDL\\Data\\Leeds_Patient_10\\19\\DICOM')
#Looks at the contents of the folder after data is sliced
Folder_Contents = os.listdir(path)
MHDImages = GetImagesMHD(Folder_Contents)
OG_GZ = []
# Reduce Number of Dimetions from [384,384,1] to [384,384]
for gz in Folder_Contents:
im = load_itk(os.path.join(path, gz))
#im = np.reshape(im,[im.shape[1],im.shape[2]])
OG_GZ.append(im)
SaveImages(OG_GZ)
FixedImagePath = os.path.join(path, 'Slice0.nii.gz')
Param = 'D:\\IDL\\FYP\\Param.txt'
for nifti in range(len(Folder_Contents) - 1):
Images = MakeFilename(path,
[['Slice' + str(nifti + 1) + '.nii.gz'][0]])
Elastix_Call(Images[0], FixedImagePath, path, Param)
RenameResultFile(path, nifti)
MhdToNifti(path, os.path.join(path,
['Result' + str(nifti) + '.mhd'][0]),
nifti + 1)
Images = MakeFilename(path, GetImagesMHD(os.listdir(path)))
for entry in Images:
ImageMatrix.append(load_itk(entry))
SaveImages(ImageMatrix)
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 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 upload():
if request.method == 'POST':
file = request.files['file']
if not allowed_file(file.filename):
return {
"status":
400,
"msg":
"provided file type not supported. "
"Expected pdf document as input"
}
if file and file.filename.endswith("pdf"):
now = datetime.now()
filename = os.path.join(
app.config['UPLOAD_FOLDER'],
"%s.%s" % (now.strftime("%Y-%m-%d-%H-%M-%S-%f"),
file.filename.rsplit('.', 1)[1]))
file.save(filename)
converter = Convert(filename)
converter.extract_text()
converter.convert_text()
return_file = converter.create_pdf()
return send_from_directory(directory=os.path.dirname(return_file),
filename=os.path.basename(return_file),
as_attachment=True)
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 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_bad_units(self):
c = Convert()
self.assertFalse(c.convert('Foo','Bar',123))
self.assertFalse(c.convert('Kelvin','Bar',456))
self.assertFalse(c.convert('Foo','Fahrenheit',789))
self.assertFalse(c.convert('Foo','Fahrenheit','abc'))
self.assertFalse(c.convert(None,None,None))
self.assertFalse(c.convert(False,False,False))
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 run_op(self, limit=None):
mapped_fields = self.map_fields()
self.files.template = self.template_entry.get()
self.files.csv_file = self.csv_entry.get()
self.files.folder = self.folder_entry.get()
Convert(self.base,
mapped_fields, self.files, self.output_as_word.get(),
self.output_as_word.get(), self.user_settings, limit)
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 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 home():
form = Home(request.form)
response = 0
if request.method == 'POST' and form.validate_on_submit():
response = Convert().do(form.currency_source.data,
form.currency_destination.data,
form.value_source.data)
return render_template('home.html', form=form, response=response)
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 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 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 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.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 __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 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 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 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 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 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 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 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 cmp_op(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)
ret = "="
if num1 < num2:
ret = "<"
elif num1 > num2:
ret = ">"
del convert
return ret
