def test_chain_validations(request_example): trip = TripValidator() trip.set_next(VanValidator()) validator = Validator(trip) assert validator.validate(request_example) is True request_example["van"]["id"] = None assert validator.validate(request_example) is False
class Todo(object): def __init__(self): self.validator = Validator() self.db = Database() self.collection_name = 'todo' self.fields = { "title": "string", "body": "string", } self.create_required_fields = ["title", "body"] # Fields optional for CREATE self.create_optional_fields = [] # Fields required for UPDATE self.update_required_fields = [] # Fields optional for UPDATE self.update_optional_fields = [] def create(self, todo): # Validator will throw error if invalid self.validator.validate(todo, self.fields, self.create_required_fields, self.create_optional_fields) res = self.db.insert(todo, self.collection_name) return "Inserted Id " + res
def test_when_all_query_params_are_set(self): limit = 5 offset = "30" filters = "distance_learning,honours_award,-foundation_year,sandwich_year,-year_abroad,full_time" length_of_course = "3,4" countries = "england,wales" subjects = "CAH09-01-01,CAH09-01-02" language = "en" validator = Validator( countries, filters, length_of_course, subjects, limit, 100, offset, language ) expected_result = { "countries": ["XF", "XI"], "distance_learning": True, "foundation_year": False, "full_time": True, "honours_award": True, "language": "en", "length_of_course": ["3", "4"], "limit": 5, "offset": 30, "sandwich_year": True, "subjects": ["CAH09-01-01", "CAH09-01-02"], "year_abroad": False, } output_result, output_error_object = validator.validate() self.assertEqual(expected_result, output_result) self.assertEqual([], output_error_object)
def test_when_all_query_params_are_bad(self): limit = 200 offset = "-30" filters = "illusion,Part_Time,full_time,-full_time" length_of_course = "-2,8,twenty" countries = "bolivia,-england,england" subjects = 32 language = "bad" validator = Validator( countries, filters, length_of_course, subjects, limit, 100, offset, language ) expected_result = {} output_result, output_error_object = validator.validate() expected_error_object = [ { "error": "limit cannot exceed maximum value of 100", "error_values": [{"limit": 200}], }, { "error": "offset needs to be a positive number, offset cannot be lower than 0", "error_values": [{"offset": "-30"}], }, { "error": "use of the same filter option more than once", "error_values": [{"filters": "full_time"}], }, { "error": "invalid filters", "error_values": [{"filters": "illusion,Part_Time"}], }, { "error": "use of the same countries more than once", "error_values": [{"countries": "england"}], }, {"error": "invalid countries", "error_values": [{"countries": "bolivia"}]}, { "error": "length_of_course values needs to be a number", "error_values": [{"length_of_course": "twenty"}], }, { "error": "length_of_course values needs to be numbers between the range of 1 and 7", "error_values": [{"length_of_course": "-2,8"}], }, { 'error': 'value of language is not supported', 'error_values': [{'language': 'bad'}], } ] print(f"output: {output_error_object}") self.assertEqual(expected_result, output_result) self.assertEqual(expected_error_object, output_error_object)
def create_item(): if not is_user(): return redirect(url_for("login")) # for form validation get an instance validate = Validator() if request.method == "POST": # get form fields values in variables name, description, category_id = \ request.form.get('name').strip(), \ request.form.get('description').strip(), \ request.form.get('category_id') # validate form fields validate.validate(name, 'Name') validate.validate(description, 'Description') validate.validate(description, 'Category Name') # if form is valid create this item and send flash message if validate.valid_form(): model.create_item(name=name, description=description, category_id=category_id, user_id=login_session['id']) flash("Item Created Successfully") return redirect(url_for("home")) categories = model.all_categories() return render_template("create_item.html", categories=categories, form_errors=validate.get_form_errors(), is_user=is_user(), login_session=login_session)
def update_item(cid, iid): # from validation instance validate = Validator() selected_category, item, category_has_item = \ model.category_item(iid=iid, cid=cid) # boolean checks if user is authorized to access this page authorized = category_has_item and is_user()\ and item.user_id == login_session['id'] if not authorized: return redirect(url_for('login')) categories = model.all_categories() if request.method == 'POST': # get fields into variables iid, name, description, category_id = \ request.form.get('id'), \ request.form.get('name').strip(), \ request.form.get('description').strip(), \ request.form.get('category_id') # validate form validate.validate(field=name, field_name='Name') validate.validate(description, 'Description') validate.validate(category_id, "Category Name") # if form valid update if validate.valid_form(): item = model.update_item(item, name=name, description=description, cid=category_id) # set message shows updated done successfully msg = "%s Item Updated Successfully" % name flash(msg) return redirect( url_for("update_item", iid=item.id, cid=item.category_id)) return render_template("update_item.html", categories=categories, selected_category=selected_category, item=item, form_errors=validate.get_form_errors(), category_has_item=category_has_item, is_user=is_user(), login_session=login_session)
class Enigma: """ This class simulates the Enigma machine As models M3 and M4 of the Enigma machine, it supports 3 or 4 rotors configuration. The order of reflector and rotors definition respect the physical order (left-to-right). :param reflector: The reflector associated to the Enigma machine :type reflector: Reflector :param *rotors: The rotors associated to the Enigma machine :type *rotors: Variable length rotor list :raises: :class:`TypeError, ValueError`: If one of the provided parameter is invalid Example:: enigma = Enigma(ReflectorB(), RotorI(), RotorII(), RotorIII("V")) enigma.encode("HELLOWORLDHELLOWORLDHELLOWORLD") enigma = Enigma(ReflectorA(), RotorIV("E", 18), RotorV("Z", 24), RotorBeta("G", 3), RotorI("P", 5)) enigma.plugboard.set("PC XZ FM QA ST NB HY OR EV IU") enigma.encode("BUPXWJCDPFASXBDHLBBIBSRNWCSZXQOLBNXYAXVHOGCUUIBCVMPUZYUUKHI") """ def __init__(self, reflector, *rotors): self._rotor_chain = RotorChain(reflector, *rotors) self.plugboard = Plugboard() self.__alpha_string_validator = Validator( TypeValidator(str), LengthValidator(1, lambda x, y: x >= y), AlphaValidator()) def encode(self, string): """ Perform the whole encoding of a string on the Enigma machine Each character of the string is first encoded by the plug board then the character is encoded through the rotor chain and finally the character is encoded by the plug board again. :param char: The string to encode :type char: str :return: The encoded string :rtype: str """ self.__alpha_string_validator.validate(string) encoded_string = "" for letter in string: encoded_string += self.plugboard.encode( self._rotor_chain.encode(self.plugboard.encode(letter))) return encoded_string def reset(self): """ Reset all rotors of the machine to position to "A" and the ring setting to 1 """ self._rotor_chain.reset() @property def plugboard(self): """ The plug board associated to the Enigma machine :getter: Returns the plug board :setter: Sets the plug board :type: Plugboard """ return self.__plugboard @plugboard.setter def plugboard(self, plugboard): self.__plugboard = plugboard @property def reflector(self): """ The reflector associated to the Enigma machine :getter: Returns the reflector :setter: Sets the reflector :type: Reflector """ return self._rotor_chain.reflector @reflector.setter def reflector(self, reflector): self._rotor_chain.reflector = reflector @property def rotors(self): """ The rotors associated to the Enigma machine :getter: Returns the list of rotors :setter: Sets the list of rotors :type: Rotors list """ return self._rotor_chain.rotors @rotors.setter def rotors(self, rotors): self._rotor_chain.rotors = rotors
BaseTransform(300, dataset_mean), AnnotationTransform()) data_loader = data.DataLoader(dataset, 32, num_workers=2, shuffle=False, collate_fn=detection_collate, pin_memory=True) from layers.modules import MultiBoxLoss criterion = MultiBoxLoss(num_classes, 0.5, True, 0, True, 3, 0.5, False, args.cuda) from validation import Validator v = Validator(data_loader, net, num_classes, criterion=criterion) AP, mAP, losses = v.validate() for idx, a in enumerate(AP): print("{0:20} AP: {1:.4f}".format(VOC_CLASSES[idx], a)) print("mAP", mAP) print( "total loss: {0:.4f}, class loss: {1:.4f}, loc loss: {2:.4f}".format( losses[0], losses[1], losses[2])) exit() net.eval() if args.cuda: net = net.cuda() cudnn.benchmark = True # evaluation
class CustomerDatabase: ''' data structure: db{customer_id:{logs:[234,34565,234,234], deposit_records:{'2019-07-01':{'1':[123.45], '2':[400.33]}}}} logs contain an array of ids deposit records contain a dictionary of beginning mondays, follwoed by weekday offsets, followed by an array of deposits for that day ''' def __init__(self): logger.info('inititlizing db') self.db = dict() self.validator = Validator() def __init_customer_data(self, customer_id): if customer_id not in self.db: logger.debug("creating new customer") default_customer = {"logs": [], "deposit_records": {}} self.db[customer_id] = default_customer return self.db[customer_id] # multiple customer_id / transaction ids not permitted. def __is_duplicate_transaction(self, logs, txn_id): in_logs = txn_id in logs return in_logs #add the transaction id to the customer log def __update_transaction_history(self, customer_id, txn_id): logs = self.db[customer_id]["logs"] logs.append(txn_id) self.db[customer_id]["logs"] = logs # add the load amount to the weekly/daily bucket def __update_db(self, customer_id, deposits): try: self.db[customer_id]["deposit_records"] = deposits except Exception as e: logger.exception(e, exc_info=True) # deposit is the only public class here - use this to load your card. def deposit(self, customer_id, txn_id, time, amount): try: amount = sanitize_currency(amount) customer_data = self.__init_customer_data(customer_id) if self.__is_duplicate_transaction(customer_data["logs"], txn_id): return False, 403 deposits = customer_data["deposit_records"] monday, date_index = breakdown_date(convert_to_utc(time)) valid_transaction = self.validator.validate( deposits, monday, date_index, amount) self.__update_transaction_history(customer_id, txn_id) if valid_transaction: if monday not in deposits: deposits[monday] = {date_index: []} if date_index not in deposits[monday]: deposits[monday][date_index] = [] deposits[monday][date_index].append(amount) self.__update_db(customer_id, deposits) return True, 200 else: return False, 406 except Exception as e: logging.exception("Could not process data", exc_info=True) sys.exit(0)