from command import Command from file_handler import FileHandler from validator import Validator cli = Command(FileHandler(), Validator()) cli.cmdloop()
def test_read_bad_data(filename):
ecg_file = FileHandler(filename, initialize=False)
time, signal = ecg_file.read_data()
assert len(time) == len(signal)
def test_read_data_bad_ext(filename):
ecg_file = FileHandler(filename, initialize=False)
with pytest.raises(TypeError):
_, _ = ecg_file.read_data()
# 根据issueId列表，循环拼接URL导出（limit、issueId）
issue_files = self.export_by_issueId()
elif self.crashDetail[0] is not '' and self.crashDetail and len(self.crashDetail) > 0:
print( self.crashDetail)
issue_files = self.export_by_crashDetail()
else:
issue_files = self.export_gray_issues()
all_issues = []
for f in issue_files:
issues_list = self.filehandler.get_json_file(f)
if issues_list:
all_issues.extend(issues_list)
self.extract_keystack()
return self.dedupe_issues(all_issues)
if __name__ == '__main__':
from file_handler import FileHandler
filehandler = FileHandler(platform='And')
e = ExportIssues(filehandler)
all_issues = [
{'issueId': 123, 'keyStack': 'java.lang.wedxdf'},
{'issueId': 234, 'keyStack': 'java.lang.wedxdf'},
{'keyStack': 'java.lang.sadf323d', 'issueId': 234},
{'issueId': 123, 'keyStack': 'java.lang.sadf323d'}
]
def test_get_basename(filename, expected):
ecg_file = FileHandler("tests/test_data/test1.csv", initialize=False)
assert ecg_file.get_basename(filename) == expected
def get_random_questions(category):
f = FileHandler()
questions = f.read_questions(category)
random_questions = sample(questions, 15)
return random_questions
import sys
from deserialization import *
from file_handler import FileHandler
from data_processing import Calculator
file_info = FileHandler(sys.argv[1])
file = None
if file_info.file_ext() == ".csv":
file = CsvFileReader(file_info.filename)
elif file_info.file_ext() == ".json":
file = JsonFileReader(file_info.filename)
else:
print ("Unsupported data format!")
if file == None:
sys.exit("Unsupported data format!")
data = file.to_list()
calc = Calculator(data)
print ("Distribution of number of fellow passengers per user: {}".format(calc.distribution()))
print ("Average compensation per passenger: {}".format(calc.average_compensation()))
print ("Most popular airline is: {}".format(calc.most_popular_airline()))
print ("Percentage of users who got compensation: {}".format(calc.percet_of_passengers_with_compensation()))
def test_02(self):
csv = FileHandler("employeeinfo.csv")
items = [
"EMPID", "GENDER", "AGE", "SALES", "BMI", "SALARY", "BIRTHDAY"
]
self.assertListEqual(csv._fieldnames, items)
def test_05(self):
csv = FileHandler("employeeinfo2.csv")
self.assertTrue(csv.file_exist())
def test_valid_file_extention(self):
csv = FileHandler("employeeinfo.csv")
self.assertTrue(type(csv._fieldnames) == list)
def test_01(self):
csv = FileHandler("employeeinfo.csv")
self.assertTrue(type(csv._fieldnames) == list)
start_t = txt.get_start_time()
m_time = int((int(m_time) - start_t) / 1000)
#temp_values = [float(y) for y in m_temp]
#fbar_values = [float(y) for y in m_fbar]
#lint_values = [float(y) for y in m_lint]
row = [str(m_time), m_temp, m_fbar, m_lint] #data are float values
return row
#### Code itself ####
# Objects declaration
ard = SerialArduino(port, baud_rate)
txt = FileHandler(user_file)
dat = Table('data')
cli = ConsoleInterface(dat) # binds data table to interface object
cli.init_interface() # prints header
op = cli.start_menu()
if op.upper() == 'Y':
#cli.setup_interface()
user_file = raw_input('Type TXT file name: ')
txt.set_name(user_file)
cli.show_warning('Hit Ctrl-C to stop acquisition')
cli.getch()
### !!! BIG INCONSISTENCY RIGHT HERE !!!
class CarLot:
vehicle_handler = FileHandler("vehicle")
user_handler = FileHandler("user")
__users = []
__vehicles = []
__employees = []
def __init__(self):
self.__vehicles = self.vehicle_handler.get_data()
self.__users = self.user_handler.get_data()
def load_employee_data(self):
role_pos = definitions.file_data.get("user").get("columns").index(
"role")
self.user_handler.load_from_csv()
all_users = self.user_handler.get_data()
self.__employees = [
row for row in all_users if row[role_pos] == 'employee'
]
return self.__employees
# need to return t/f and add error handling
def update_salary_by_name(self, employee_salary, name):
name = name.lower()
all_employees = []
found = False
first_name_pos = definitions.file_data.get("user").get(
"columns").index("first_name")
last_name_pos = definitions.file_data.get("user").get("columns").index(
"last_name")
salary_pos = definitions.file_data.get("user").get("columns").index(
"salary")
for row in self.__users:
if row[last_name_pos].lower(
) == name or f"{row[first_name_pos]} {row[last_name_pos]}".lower(
) == name:
found = True
new_data = [
item if index != salary_pos else employee_salary
for index, item in enumerate(row)
]
all_employees.append(new_data)
else:
all_employees.append(row)
# user file handler class to write updated info to csv
self.user_handler.write_to_csv(all_employees)
# checks if employee successfully given raise
if found:
return True
else:
return False
def add_to_fleet(self, external_csv_fleet_file):
data = FileHandler(external_csv_fleet_file)
data.load_from_csv()
provided_details = data.get_data()[0]
required_details = definitions.file_data.get("vehicle").get("columns")
if collections.Counter(required_details) == collections.Counter(
provided_details):
# add to vehicle csv file
self.vehicle_handler.append_multiple_to_csv(data.get_data()[1:])
return True
else:
return False
def get_fleet_size(self):
return len(self.__vehicles)
def get_all_cars_by_brand(self, brand):
try:
brand_pos = definitions.file_data.get("vehicle").get(
"columns").index("brand")
wanted = [
row for row in self.__vehicles if row[brand_pos] == brand
]
return len(wanted)
except Exception as e:
print("Error: " + str(e))
def how_many_own_more_then_one_car(self):
owner_pos = definitions.file_data.get("vehicle").get("columns").index(
"owner")
all_owners = [row[owner_pos] for row in self.__users]
owners_of_more_than_one_car = [
name for name in all_owners if all_owners.count(name) > 1
]
# remove duplicate names
return list(set(owners_of_more_than_one_car))
def get_all_cars_by_filter(self, and_or="and", **kwargs):
if and_or == "or":
matches = [
row for row in self.__vehicles for k, v in kwargs.items()
if v in row
]
else:
matches = []
for row in self.__vehicles:
all_match = True
for k, v in kwargs.items():
cur_key = definitions.file_data.get("vehicle").get(
"columns").index(k)
if row[cur_key].lower() != kwargs[k].lower():
all_match = False
if all_match:
matches.append(row)
return matches
def does_employee_have_car(self, name):
owner_pos = definitions.file_data.get("vehicle").get("columns").index(
"owner")
brand_pos = definitions.file_data.get("vehicle").get("columns").index(
"brand")
search_employee = [
row for row in self.__vehicles if row[owner_pos] == name
]
if len(search_employee) == 0:
return False
else:
return f"Employee {name} owns a {search_employee[0][brand_pos]}"
def all_employees_with_car(self):
employees = []
self.load_employee_data()
for employee in self.__employees:
answer = self.does_employee_have_car(
f"{employee['first_name']} {employee['last_name']}")
if answer:
employees.append(answer)
return employees
def get_all_employee_who_own_car_brand(self, brand):
employees_with_brand = []
employees_with_cars = self.all_employees_with_car()
for employee in employees_with_cars:
answer = self.get_all_cars_by_filter(name=employee, brand=brand)
employees_with_brand.append(answer)
return employees_with_brand
def __init__(self,nombre):
self.nombre = nombre
self.file_handler = FileHandler('./datos.txt')
def test_save_data_in_list_format(self):
csv = FileHandler("employeeinfo.csv")
self.assertTrue(type(csv.read()) == list)
def test_11(self):
csv = FileHandler("employeeinfo.csv")
self.assertRaises(AttributeError, csv.save, "This is a data list")
def __init__(self, user):
self.user = user
self.file_handler = FileHandler()
def test_14(self):
csv = FileHandler("employeeinfo.csv")
self.assertTrue(type(csv.read()) == list)
)
print(
'For the base64-iv you need to find the value of the cb-encryptioninfo header. It will '
'have a semi-colon seperated string like: 1;190728;AES;256;kgAAAAAAwlXSWZGeLJlaWg==;;;'
)
print(
'The 5th item is the base64 encoded "IV" value which is kgAAAAAAwlXSWZGeLJlaWg== in '
'this case. You will need this to decrypt the file (it is different for each file).'
)
exit()
password = sys.argv[1] # Cloudberry client-side encryption password
base64iv = sys.argv[2] # Base64 IV from 'cb-encryptioninfo' metadata header
algorithm = sys.argv[3].upper() # AES128 or AES256
compressed = sys.argv[4].lower() == 'y'
file_to_decrypt = sys.argv[5]
encrypted_file = open(file_to_decrypt, 'rb')
encrypted_data = encrypted_file.read()
encrypted_file.close()
file_handler = FileHandler(algorithm=algorithm, password=password)
decrypted_data = file_handler.get_contents(path=file_to_decrypt,
base64iv=base64iv,
compressed=True,
encrypted=True)
decrypted_file = open(file_to_decrypt, 'wb')
decrypted_file.write(decrypted_data)
decrypted_file.close()
def start_process(input_file, output_file):
handler = FileHandler(input_file, output_file)
info = handler.read_file()
error_msgs = info['error_msgs']
if len(info['ref_words']) > 0:
parser = InputParser(DEFAULT_ANSWER)
result = parser.process_info(info['ref_words'], info['price_msgs'])
if result:
error_msgs.extend(result)
answers = parser.answer_questions(info['questions'])
handler.write_file(answers, error_msgs)
else:
handler.error_output("No correct inputs found.")
if __name__ == '__main__':
input_file = sys.argv[1] if len(sys.argv) > 1 else 'input.txt'
output_file = sys.argv[2] if len(sys.argv) > 2 else 'output.txt'
if not os.path.isfile(input_file):
handler = FileHandler('', output_file)
handler.error_output("Can't find the input file: " + input_file)
exit(1)
start_process(input_file, output_file)
def filtered_signal_obj(file_num):
filename = "tests/test_data/test_data{}.csv".format(file_num)
file = FileHandler(filename)
filtered_signal_sp = FilteredSignal(file.time, file.signal)
return filtered_signal_sp
def test_csv_file_handler(self):
csv = FileHandler("staffinfo.csv")
self.assertTrue(type(csv._fieldnames) == list)
from afn import AFN
from file_handler import FileHandler
from utils.compere import compere
compere()
path = "./quintuple.txt"
handler = FileHandler(path)
quintuple = handler.read_file()
afn = AFN(*quintuple)
result = afn.validate("abcbb")
afn.display_acceptation_paths("abcbb")
def test_file_data_format(self):
csv = FileHandler("staffinfo.csv")
items = [
"EMPID", "GENDER", "AGE", "SALES", "BMI", "SALARY", "BIRTHDAY"
]
self.assertListEqual(csv._fieldnames, items)
def test_get_ext(filename, expected):
ecg_file = FileHandler(filename, initialize=False)
assert ecg_file.get_ext() == expected
def test_file_exists(self):
csv = FileHandler("staffinfo2.csv")
self.assertFalse(csv.file_exist())
def test_read_data_no_file(filename):
ecg_file = FileHandler(filename, initialize=False)
with pytest.raises(FileNotFoundError):
_, _ = ecg_file.read_data()
def test_file_type_error(self):
csv = FileHandler("staffinfo.csv")
self.assertRaises(AttributeError, csv.save, "This is a data list")
def test_write_bad_data(data):
test_file_path = "tests/test_data/test_json.json"
ecg_file = FileHandler("/test_data/test1.csv", initialize=False)
with pytest.raises(TypeError):
ecg_file.write_data(data, test_file_path)
from file_handler import FileHandler
from processor import ListProcessor
file_IO = FileHandler()
waypoints = file_IO.read_waypoints('data/waypoints.json')
list_proc = ListProcessor(waypoints)
trips = list_proc.get_trips()
file_IO.save_trips(trips)
