def testBlah(self):
e = expression.parse("(A>>7)<<1")
e = e.optimizedWithContext(context.Context())
self.assertEquals(str(e), "(A >> 6) & 2")
e = expression.parse("(A>>4)<<6")
e = e.optimizedWithContext(context.Context())
self.assertEquals(str(e), "(A << 2) & 0xc0")
def filled(self, params, ctx):
reads = set()
writes = set()
values = dict()
loads = []
for x in self.reads:
if x.startswith("#"):
assert(len(x) == 2)
value = params[x[1]]
operand = placeholders.get(x[1], value)
if hasattr(operand, 'target'):
reads.add('mem')
reads |= regutil.splitRegister('HL') # TODO: XXX: bad
else:
reads |= regutil.splitRegister(operand.name)
else:
reads |= regutil.splitRegister(x)
for x in self.writes:
if x.startswith("#"):
assert(len(x) == 2)
value = params[x[1]]
operand = placeholders.get(x[1], value)
if hasattr(operand, 'target'):
name = '['+operand.target.name+']'
writes.add('mem')
reads |= regutil.splitRegister('HL') # TODO: XXX: bad
else:
name = operand.name
writes |= regutil.splitRegister(name)
if x in self.values:
e = expression.parse(self.values[x])
values[name] = e.optimizedWithContext(ctx)
loads.append((name, values[name]))
else:
writes |= regutil.splitRegister(x)
if x in self.values:
e = expression.parse(self.values[x])
values[x] = e.optimizedWithContext(ctx)
loads.append((x, values[x]))
#values = dict() # TODO: XXX:
#loads = []
return reads, writes, values, loads
def remove(item):
connection = database.get_current_gallery("connection")
c = connection.cursor()
c.execute(
"SELECT file_name FROM file WHERE pk_id=:file",
{
"file": item
}
)
filename = c.fetchone()
if filename is None:
raise ValueError("No file with this id", item)
c.execute(
(
"SELECT location, name FROM gallery_folder AS g "
"LEFT JOIN gallery_folder_has_tag AS gt "
"ON g.pk_id = gt.pk_fk_gallery_folder_id "
"LEFT JOIN file_has_tag AS ft "
"ON gt.pk_fk_tag_id = ft.pk_fk_tag_id "
"WHERE ft.pk_fk_file_id=:file "
"GROUP BY g.pk_id"
),
{
"file": item
}
)
folders = c.fetchall()
for folder in c.execute("SELECT location, name, expression FROM folder"):
c.execute(
(
"SELECT pk_id FROM file "
"WHERE :expression AND pk_id=:file"
),
{
"expression": expression.parse(folder[2]),
"file": item
}
)
if c.fetchone() is None:
continue
folders.append(folder[0:2])
# Get tag name
tags = tagging.get_tag_names(item)
for folder in folders:
for tag in tags:
path = os.path.join(
folder[0],
folder[1],
tag.replace("_", " "),
filename[0]
)
if os.path.exists(path):
os.remove(path)
def change_expression(id, new_expression):
connection = database.get_current_gallery("connection")
c = connection.cursor()
# get folder
c.execute(
(
"SELECT location, name, use_softlink "
"FROM folder "
"WHERE pk_id = ?"
),
(id,)
)
output = c.fetchone()
if output is None:
raise ValueError("Invalid folder id", id)
# parse expression
where = expression.parse(new_expression)
# remake folder
folder = os.path.join(output[0], output[1])
if os.path.isdir(folder):
shutil.rmtree(folder)
os.makedirs(folder)
# relink files
c.execute(
(
"SELECT uuid, file_name "
"FROM file "
"WHERE {}"
).format(where)
)
files = c.fetchall()
if files is not None:
gallery = database.get_current_gallery("directory")
for file in files:
source = os.path.join(gallery, "files", file[0])
target = os.path.join(folder, file[1])
create_folders.symlink(source, target, output[2])
# update db
c.execute(
(
"UPDATE folder "
"SET expression = ? "
"WHERE pk_id = ?"
),
(new_expression, id),
)
connection.commit()
def create_folders():
# Get gallery connection
gallery_conn = database.get_current_gallery("connection")
cursor = gallery_conn.cursor()
# Get output folders
query_folders = ("SELECT name, location, "
"expression, use_softlink FROM folder")
cursor.execute(query_folders)
folders = cursor.fetchall()
for folder in folders:
name = folder[0]
location = folder[1]
folder_expression = folder[2]
dest = os.path.join(location, name)
if folder[3] == 1:
use_softlink = True
else:
use_softlink = False
if not os.path.exists(dest):
os.makedirs(dest)
# Get files
query_files = ("SELECT file_name, uuid FROM file WHERE %s" %
(expression.parse(folder_expression)))
cursor.execute(query_files)
files = cursor.fetchall()
for file in files:
name = file[0]
uuid = file[1]
destination = os.path.join(dest, name)
if not os.path.exists(destination):
source = os.path.join(
os.path.join(database.get_current_gallery("directory"),
"files"), uuid)
symlink(source, destination, use_softlink)
def testConstantOptimize(self):
ctx = context.Context()
ctx.setValue('A', operand.Constant(1))
e = expression.parse("1+A")
e = e.optimizedWithContext(ctx)
self.assertEquals(e.value, 2)
def fillOperand(text, params, argument, next_addr):
e = expression.parse(text)
ctx = make_context(params, argument, next_addr)
return e.optimizedWithContext(ctx)
def change(item, tag, create):
connection = database.get_current_gallery("connection")
c = connection.cursor()
c.execute(
(
"SELECT uuid, file_name "
"FROM file "
"WHERE pk_id=:id"
),
{
"id": item
}
)
# TODO better var name
g_file = c.fetchone()
if g_file is None:
raise ValueError("No file with this id", item)
target = os.path.join(
database.get_current_gallery("directory"),
"files",
g_file[0]
)
# gallery output folders
c.execute(
"SELECT pk_id, location, name, use_softlink "
"FROM gallery_folder"
)
folders = c.fetchall()
for folder in folders:
c.execute(
(
"SELECT name "
"FROM gallery_folder_has_tag "
"JOIN tag ON pk_fk_tag_id=pk_id "
"WHERE pk_fk_gallery_folder_id=:folder AND pk_id=:tag"
),
{
"folder": folder[0],
"tag": tag
}
)
tag_name = c.fetchone()
if tag_name is None:
# gallery output does not use this tag
continue
else:
tag_name = tag_name[0]
path = os.path.join(folder[1], folder[2], tag_name.replace("_", " "))
if not os.path.isdir(path):
os.makedirs(path)
link_path = os.path.join(path, g_file[1])
if create:
# create
if os.path.exists(link_path):
os.remove(link_path)
create_folders.symlink(target, link_path, folder[3])
else:
# delete
if os.path.lexists(link_path):
os.remove(link_path)
# advanced output folders
c.execute(
"SELECT location, name, expression, use_softlink "
"FROM folder"
)
folders = c.fetchall()
for folder in folders:
path = os.path.join(folder[0], folder[1])
link = os.path.join(path, g_file[1])
query_file = (
"SELECT pk_id "
"FROM file "
"WHERE %s AND pk_id = %d"
% (expression.parse(folder[2]), item)
)
c.execute(query_file)
matches = c.fetchone()
if matches is None and os.path.exists(link):
os.remove(link)
elif matches is not None:
if os.path.exists(link):
os.remove(link)
if not os.path.isdir(path):
os.makedirs(path)
create_folders.symlink(target, link, folder[3])
def rename_file(id, new_name):
connection = database.get_current_gallery("connection")
c = connection.cursor()
# get file information
c.execute("SELECT file_name FROM file WHERE pk_id = ?", (id,))
old_name = c.fetchone()
if old_name is None:
raise ValueError("Invalid file id", id)
old_name = old_name[0]
# get folders
outputs = []
# get gallery folders
c.execute("SELECT location, name, pk_id FROM gallery_folder")
folders = c.fetchall()
if folders is not None:
for folder in folders:
# get all matching tags
c.execute(
(
"SELECT name "
"FROM tag "
"JOIN gallery_folder_has_tag g ON g.pk_fk_tag_id = pk_id "
"JOIN file_has_tag t ON t.pk_fk_tag_id = pk_id "
"WHERE g.pk_fk_gallery_folder_id = ? "
"AND t.pk_fk_file_id = ?"
),
(
folder[2],
id,
),
)
tags = c.fetchall()
if tags is not None:
for tag in tags:
outputs.append(os.path.join(folder[0], folder[1], tag[0]))
# get advanced folders
c.execute("SELECT pk_id, expression FROM folder")
folders = c.fetchall()
if folders is not None:
for folder in folders:
# test expression
where = expression.parse(folder[1])
c.execute(
"SELECT pk_id FROM file WHERE pk_id = ? AND {}".format(where),
(id,),
)
test = c.fetchone()
if test is None:
continue
# expression matches file
c.execute(
"SELECT location, name FROM folder WHERE pk_id = ?",
(folder[0],),
)
folder = c.fetchone()
outputs.append(os.path.join(folder[0], folder[1]))
# rename links
for output in outputs:
source = os.path.join(output, old_name)
target = os.path.join(output, new_name)
if os.path.exists(source):
os.rename(source, target)
# update db
c.execute(
"UPDATE file SET file_name = ? WHERE pk_id = ?",
(new_name, id),
)
connection.commit()
import expression as ex
expr = input('Enter expression: ')
print('Result: ', ex.calc(ex.sort(ex.parse(''.join(expr.split())))))
