def choose_sheet(self, wb):
sheet_names = wb.sheetnames
# default to the first sheet
sheet = wb.worksheets[0]
if len(sheet_names) > 1:
print("Sheets:\n")
i = 1
for sheet in sheet_names:
print(str(i) + ") " + sheet)
i += 1
while True:
sheet_number = self.get_input(
"\nEnter the sheet number to read >>> ")
try:
sheet_number -= 1
sheet = wb.worksheets[int(sheet_number)]
break
except IndexError or KeyError or ValueError:
print(Err.get_error_message(102, sheet_number))
except TypeError:
print(Err.get_error_message(106, "numbers"))
return sheet
def call_file(self, switch, separator):
file_name = input("Please enter the filename to read data from >>> ")
split_filename = file_name.split(".")
file_extension = split_filename[-1]
if file_extension == "xls" or file_extension == "xlsx":
try:
wb = load_workbook(file_name)
except FileNotFoundError:
print(Err.get_error_message(201))
self.call_file(switch)
except OSError:
print(Err.get_error_message(103))
self.call_file(switch)
i = Dbexel()
data_to_save = i.create_connection(wb, switch)
self.write_file(data_to_save)
elif file_extension == "txt" or file_extension == "csv":
try:
self.split_file(file_name, switch, separator)
except FileNotFoundError:
print(Err.get_error_message(201))
self.call_file(switch)
except OSError:
print(Err.get_error_message(103))
self.call_file(switch)
else:
print(Err.get_error_message(204))
def write_file(self, dict_valid): # Claye
u = input("Are you sure you want to save data? Y/N >>> ")
if u.upper() == "Y":
# Rochelle
db = input("Do you want to save to a database ot file? D/F >>> ")
if db.upper() == "D": # Rochelle
self.write_to_database(dict_valid) # Rochelle
elif db.upper() == "F":
file_target = input("Please input filename to save to >>> ")
if self.check_path_exists(file_target):
u2 = input("File exists, do you want to append Y/N >>> ")
if u2.upper() == 'Y':
self.commit_save(dict_valid, file_target)
if u2.upper() == 'N':
self.write_file(dict_valid)
else:
self.commit_save(dict_valid, file_target)
else:
print(Err.get_error_message(102))
self.write_file(dict_valid)
elif u.upper() == "N":
print("Data Not saved")
else:
print(Err.get_error_message(102))
self.write_file(dict_valid)
def division_type(cls, other_type, pos):
if other_type == float_:
return float_
if other_type == int_:
return float_
ErrorHandler.error(IncompatibleTypesError(
f"Types {cls} and {other_type} are not compatible for division", pos))
def and_type(cls, other_type, pos):
"""Return the resulting type from a and operation with
this type and other variable's type or raise and error if it
is not supported.
Args:
other_type (type_): Type of the other variable.
pos (int): Position of the statement to use in errors.
"""
ErrorHandler.error(IncompatibleTypesError(
f"{cls} type doesn't support and operation", pos))
def open_file(self):
file = None
try:
file = open(self.FILE_NAME)
except FileNotFoundError or OSError:
print(Err.get_error_message(404, self.FILE_NAME))
sys.exit()
except:
print(Err.get_error_message(406, self.FILE_NAME))
sys.exit()
return file
def choose_file(self):
while True:
file_name = input("\nPlease enter the excel file to read >>> ")
try:
wb = load_workbook(file_name)
break
except FileNotFoundError:
print(Err.get_error_message(201))
except OSError:
print(Err.get_error_message(103))
return wb
def _read_file(self, file_name, direction):
file_contents = ""
if file_name:
try:
file_contents = open(file_name, "r")
except FileNotFoundError:
print(Err.get_error_message(201))
except OSError:
print(Err.get_error_message(102))
Lfh.output_file(file_contents, direction)
else:
print(Err.get_error_message(204))
def __init__(self, gitRepo, app, system, settings):
QWidget.__init__(self)
from errors import ErrorHandler, DialogErrorView
self.settings = settings
self.errors = ErrorHandler(DialogErrorView(self, app))
self.session = Session(gitRepo, self.errors)
self.text_saved = True
self.buttons_bar = QWidget()
self.project_tree = SourcesTree(self.session, system, self.errors)
self.project_tree.source_selection_changed.connect(
self._on_file_selection_)
self.session.sources_changed.connect(self.project_tree.update_model)
self.editor = EditorPanel(self.settings)
self.session.content_changed.connect(self.editor.displayText)
self.editor.content_changed.connect(
lambda: self.session.set_active_file_content(self.editor.plainText
))
self.webview = QWebView()
self.images_gallery = ImagesPanel(self.session, self.settings)
self.session.html_output_changed.connect(
lambda: self.display_local_html_file(self.session.
active_file_output))
self.session.html_content_changed.connect(
lambda: self.webview.reload())
self.images_gallery.on_insert_image.connect(
self.insert_image_in_current_position)
self.layout_toolbar()
self.layout_components()
self.session.start()
any_file = find_first_file(self.session.get_sources_structure())
if any_file:
self.project_tree.setSelectedFile(any_file)
def compare_type(cls, other_type, pos):
"""Return the resulting type from a compare operation with
this type and other variable's type or raise and error if it
is not supported.
Args:
other_type (type_): Type of the other variable.
pos (int): Position of the statement to use in errors.
"""
if cls != other_type:
ErrorHandler.error(IncompatibleTypesError(
f"Types {cls} and {other_type} are not compatible for comparison", pos))
return
return bool_
def confirm(self, action_name):
result = False
prompt = "Are you sure you want to {}? Y/N".format(action_name)
user_input = cv.get_input(prompt)
try:
if user_input[0].lower() == "y":
result = True
except IndexError:
print(Err.get_error_message(102))
self.confirm(action_name)
except Exception as e:
print(Err.get_error_message(104, e))
return result
def load_pickle_file(self): # Claye, Graham
file_target = input("Please input the filename to load from >>> ")
# self.commit_pickle_save(file_target, data_to_write)
try:
file = open(file_target, "rb")
except FileNotFoundError:
print(Err.get_error_message(201))
except OSError:
print(Err.get_error_message(103))
with open(file_target) as file:
lines = file.readlines()
print(lines)
return lines
def pie_chart(self, choice):
chart = ChartPie()
data_labels = []
title = ""
window_title = ""
data = []
if choice == 'gender':
data_labels = "Female", "Male"
title = "Gender of Staff"
window_title = "Gender Pie Graph"
data = [self.count_gender_f, self.count_gender_m]
elif choice == 'sales':
data_labels = "< 250", "250 - 499", "500 - 749", "750 - 999"
title = "Sales Brackets of Staff"
window_title = "Sales Brackets of Staff"
data = [
self.count_sales_group1, self.count_sales_group2,
self.count_sales_group3, self.count_sales_group4
]
else:
print(Err.get_error_message(601))
if title:
attributes = {
'title': title,
'data_labels': data_labels,
'window_title': window_title
}
chart.create_pie_chart(data, attributes)
def commit_save(self, dict_valid, file_target, ids_already_in_file=[]): # Claye and Graham
dup_keys = 0
rows_saved = 0
rows = 0
try:
z = open(file_target, "a")
for key in dict_valid:
if key not in ids_already_in_file:
z.write("\n")
z.write(key + ",")
for value in dict_valid[key]:
h = str(dict_valid[key][value] + ",")
z.write(value + ' ' + h)
rows_saved += 1
rows += 1
else:
dup_keys += 1
rows += 1
z.write("\n")
z.close()
if dup_keys == 0:
print("File saved, {} rows added".format(rows_saved))
elif dup_keys == rows:
print("All ID's already existed in the output file. Nothing added.")
elif dup_keys > 0:
print("{} of {} rows were duplicate keys and not inserted again".format(dup_keys, rows))
print("{} rows were added, and the file saved".format(rows_saved))
except OSError:
print(Err.get_error_message(103))
self.write_file(dict_valid)
def __init__(self):
print("Loading...")
try:
from errors import ErrorHandler as Err
except NameError and ModuleNotFoundError and ImportError:
print("Fatal Error - Errors.py not found.")
sys.exit()
try:
from cmdline import CommandLine as Cmd
except NameError and ModuleNotFoundError and ImportError:
print(Err.get_error_message(404, "cmd"))
sys.exit()
os.system('cls')
print(self.__doc__)
user_args = []
try:
user_args = sys.argv[1:]
except TypeError:
pass
Cmd().run_commandline(user_args)
def write_file(self, dict_valid, my_controller): # Claye
u = self.get_input("Are you sure you want to save data? Y/N >>> ")
if u.upper() == "Y":
# Rochelle
db = self.get_input("Do you want to save to a database or file?"
" D/F (default: F) >>> ")
if db.upper() == "D": # Rochelle
self.write_to_database(self, dict_valid) # Rochelle
else:
file_target = self.get_input("Please input filename to save"
" to >>> ")
if my_controller.check_path_exists(file_target):
u2 = self.get_input("File exists, do you want to append"
" Y/N >>> ")
if u2.upper() == 'Y':
ids_already_in_file = self.remove_duplicates(
file_target)
self.commit_save(dict_valid, file_target,
ids_already_in_file)
if u2.upper() == 'N':
self.write_file(self, dict_valid, my_controller)
else:
self.commit_save(dict_valid, file_target)
elif u.upper() == "N":
print("Data Not saved")
else:
print(Err.get_error_message(102))
def _pie(self):
if self.user_string == 'sales' or self.user_string == 'gender':
valid_data = self.get_data(self.user_string)
if valid_data:
valid_data.pie_chart(self.user_string)
else:
print(Err.get_error_message(102))
def __init__(self):
print("Loading...")
sys.path.insert(0, 'G:\OneDrive\OneDrive - Ara Institute of Canterbury\Python\Ass 2 - Original Code')
try:
from errors import ErrorHandler as Err
except NameError and ModuleNotFoundError and ImportError:
print("Fatal Error - Errors.py not found.")
sys.exit()
try:
from cmdline import CommandLine as Cmd
except NameError and ModuleNotFoundError and ImportError:
print(Err.get_error_message(404, "cmd"))
sys.exit()
os.system('cls')
print(self.__doc__)
user_args = []
try:
user_args = sys.argv[1:]
except TypeError:
pass
Cmd().run_commandline(user_args)
def main(args):
"""Main entry point for Boink. Apply necessary operations
with the given arguments.
Args:
args (Namespace): Arguments supplied by the user.
"""
if args.command == 'run':
try:
with open(args.file, 'r') as file:
# Extra newline for parsing.
inp = file.read() + '\n'
except FileNotFoundError:
print(Colr(f"File '{args.file}' not found.", fore="red"))
return
# Handler for exceptions during lexing, parsing and semantic analysis.
error_handler = ErrorHandler()
lexer_ = Lexer(inp, error_handler)
# Assign lexer to convert positions to line and offset.
error_handler.lexer = lexer_
parser_ = Parser(lexer_, error_handler)
# Root node of the program a.k.a. the program itself.
# Argument is the program name which is equivalent to file's name.
root = parser_.parse(os.path.basename(args.file))
parser_.log_tree(root)
symbol_tree_builder = SymbolTableBuilder(error_handler)
symbol_tree_builder.visit(root)
symbol_tree_builder.log_info()
if not error_handler.errors:
interpreter_ = Interpreter(root, error_handler)
else:
error_handler.log_all()
else:
print(Colr(f"Command {repr(args.command)} doesn't exist", fore="red"))
return
def put(self, request, pk, format=None):
# ============================================================
# Data processing
instance, status = self.get_object(pk=pk) # Object permission purpose
if status is st.HTTP_404_NOT_FOUND:
return Response(data=instance, status=status)
# Filter the data
# - First setup handler
if hasattr(self, "deSerializer"):
handler = ErrorHandler(self.deSerializer)
else:
handler = ErrorHandler(self.serializer)
data = request.data
if "id" in data:
data.pop("id") # id should be expected to be pk
if hasattr(self, "pre_save_handler"):
# - If the api has its own pre_save_handler
# for further processing of the data
# before passing through handler.validate()
data = self.pre_save_handler(request, handler)
else:
# - If no, just use the handler.validate()
data = handler.validate(request.data)
errors = handler.errors
# if errors:
# return Response(data=errors)
data['id'] = pk # If the data contains id, should preserve it
# otherwise it will be filtered out by
# serilizer
# ============================================================
# Perform update
crud = Crud(request.user, self.model)
from django.db.models.fields import FieldDoesNotExist
try:
# If the model has 'owner' field
# only the object that is owned by the user can be updated
print('\n\tXDetailAPIView.put, data = %s' % (data))
self.model._meta.get_field("owner")
instance, errors = crud.update(data, owner=request.user)
# return Response(data=errors)
except FieldDoesNotExist, e:
# If the model does not have 'owner' field
# pass in <user> to the model methods, let them decide
print(
"\n\ttXDetailAPIView: FieldDoesNotExist, error = %s\n" % (e.message)
)
instance, errors = crud.update(data, user=request.user)
def check_path_exists(path): # Claye
try:
if os.path.exists("{}".format(path)):
return True
else:
return False
except OSError:
print(Err.get_error_message(103))
def _run_switch_methods(self, methods_to_run):
for method in methods_to_run:
try:
method()
except TypeError:
pass
except Exception as e:
print(Err.get_error_message(901, e))
def open_file(self, file_name, mode='r'):
file = ""
try:
file = open(file_name, mode)
except FileNotFoundError:
try:
print(Err.get_error_message(403, "log"))
print("Creating log file...")
self._create_file(self, file_name)
except OSError:
print(Err.get_error_message(401, "log"))
except:
print(Err.get_error_message(402, "log"))
else:
print("log.txt file created")
return file
def _default(self):
file_contents = Lfh.load_file_data(Lfh, self.FILE_NAME)
direction = ""
if len(file_contents) == 0:
print(Err.get_error_message(208))
Lfh.output_file(file_contents, direction)
def _line(self):
# line chart for sales and salary
if self.user_string:
print(Err.get_error_message(102))
else:
valid_data = self.get_data('line')
if valid_data:
valid_data.line_chart()
def _bar(self):
# bar chart for birthday or bmi
if self.user_string == 'bmi' or self.user_string == 'birthday':
valid_data = self.get_data(self.user_string)
if valid_data:
# user string for checking which chart dat type
valid_data.bar_chart(self.user_string)
else:
print(Err.get_error_message(102))
def fetch_text_file(file_name):
file = ""
try:
file = open(file_name, "r")
except FileNotFoundError:
print(Err.get_error_message(201))
return file
def _unpickle_errors(self):
un_pickled_data = ""
try:
un_pickled_data = Pkl.unpickle_data(self.pickled_errors[0])
except IndexError:
print(Err.get_error_message(208))
if self.display_detail_output:
print("Unpickled Data: {}".format(un_pickled_data))
return un_pickled_data
def load_file_data(self, file_name):
file_contents = []
try:
with self.open_file(self, file_name, "r") as file:
for line in file:
a_line = line.rstrip()
file_contents.append(a_line)
self.close_file(file)
except FileNotFoundError:
try:
print(Err.get_error_message(403, "log"))
print("Creating log file...")
self._create_file(self, file_name)
except OSError:
print(Err.get_error_message(401, "log"))
except:
print(Err.get_error_message(402, "log"))
else:
print("log.txt file created")
return file_contents
def call_file(self, switch, separator=','):
valid_dict = None
file_name = input("Please enter the filename to read data from >>> ")
split_filename = file_name.split(".")
file_extension = split_filename[-1]
wb = None
file = None
if file_extension == "xls" or file_extension == "xlsx":
try:
wb = self.file_reader.fetch_workbook_file(file_name)
except FileNotFoundError:
print(Err.get_error_message(201))
self.call_file(self, switch)
except OSError:
print(Err.get_error_message(103))
self.call_file(self, switch)
if wb is not None:
data_to_save = self.file_reader.fetch_workbook_contents(
wb, switch)
FileWriter.write_file(FileWriter, data_to_save, self)
elif file_extension == "txt" or file_extension == "csv":
try:
open(file_name, 'r')
except FileNotFoundError:
print(Err.get_error_message(201))
self.call_file(self, switch)
except OSError:
print(Err.get_error_message(103))
self.call_file(self, switch)
else:
file = self.file_reader.fetch_text_file(file_name)
if file is not None:
valid_dict = self.file_reader.fetch_text_contents(
file, switch, separator)
else:
print(Err.get_error_message(204))
if valid_dict:
FileWriter.write_file(FileWriter, valid_dict, self)
def _load_file_data(self, file_name):
file_contents = []
try:
with open(file_name, "r") as file:
for line in file:
a_line = line.rstrip()
file_contents.append(a_line)
file.close()
except FileNotFoundError:
print(Err.get_error_message(403, "requested file"))
return file_contents
