def save(url, uri=None, info=None): uri = uri or url key = create_key(uri, 'full', 'max', '0', 'default', get_setting('cache_format', 'jpg')) info = info or get_info(url, uri, download=False) if not info: i = get_image(uri, url) info = {'width': i.width, 'height': i.height, 'format': i.format} i = get_image(url, uri) # quick hack to avoid tiling of JPEG2000 images when cached if get_setting('cache_original', False) and get_setting( 'opj_decompress', None) and i.format == 'JPEG2000': # do nothing for now ... else: # save full size? if get_setting('cache_full', False) and not get_setting('save_original', False): save_to_cache( create_key(uri, 'full', 'max', '0', 'default', get_setting('cache_format', 'jpg')), i) ingest(i, url, uri) # write info info = {'width': i.width, 'height': i.height, 'format': i.format} cache.set(uri, dumps(info)) return info
def ingest(i, url, uri=None): tile_size = get_setting('tile_size', '512') min_n = int(log2(tile_size)) max_n = int(min(log2(i.width), log2(i.height))) uri = uri or url for n in reversed(range(min_n, max_n + 1)): size = 2**n for x in range(0, int((i.width - 1) / size) + 1): for y in range(0, int((i.height - 1) / size) + 1): offset_x = size * x offset_y = size * y width = min(size, i.width - offset_x) height = min(size, i.height - offset_y) i2 = i.crop((offset_x, offset_y, offset_x + width, offset_y + height)) \ .resize((round((2**min_n * width)/size), round((2**min_n*height)/size)), Image.LANCZOS) if n != min_n: i2 = i2.filter( ImageFilter.UnsharpMask(radius=0.8, percent=90, threshold=3)) save_to_cache( create_key( uri, #','.join( [ str(size*x), str(size*y), str(size*(x+1)-1), str(size*(y+1)-1) ], ','.join([ str(offset_x), str(offset_y), str(width), str(height) ]), #'!512,512', ','.join([ str(round((2**min_n * width) / size)), str(round((2**min_n * height) / size)) ]), '0', 'default', get_setting('cache_format', 'jpg'), width=i.width, height=i.height, normalize=True), i2) for extra in get_setting('prerender', []): save_to_cache(create_key(uri, **extra), create_image(i, **extra))
def get_image(url, uri=None): uri = uri or url print(f'get image: {url}', flush=True) if url.startswith('file:///'): s = open(url[7:], mode='rb') else: req = hget(url, stream=True) req.raw.decode_stream = True s = req.raw if get_setting('cache_original', False) and not url.startswith('file:///'): print(f'caching original ({uri})', flush=True) key = uri + ':original' cache.set(key, s) i = Image.open(join(*cache.get_location(key))) else: b = s.read() i = Image.open(BytesIO(b)) if get_setting('cache_full') and not url.startswith('file:///'): # TODO file size sanity check key = create_key(uri, 'full', 'max', '0', 'default', get_setting('cache_format', 'jpg')) print(f'caching original ({key})', flush=True) save_to_cache(key, i) return i
def scrape_before_2016(soup): all_org_data = {} orgs = soup.findAll( 'li', attrs={'class': 'mdl-list__item mdl-list__item--one-line'}) for org in orgs: link = org.find('a') org_name = link.text all_org_data[create_key(org_name)] = { "name": org_name, } return all_org_data
def get_random(valid: bool = True) -> dict: """Returns a random ID with it's corresponding private key""" key = create_key() pubkey = parse_key(key.publickey()) username = random_word(random.randint(1, USERNAME_LIMIT)) if valid is False: username = "******" * (USERNAME_LIMIT + 1) return {"private_key": parse_key(key), "id": ID(username, pubkey)}
def newUser(): student_login = '' while student_login == '': student_login = input('login insper: ').strip() student_key = create_key(f'students/{student_login}.key') student_name = input('nome completo: ') ghname = input('usuário do github: ') s = Student(student_login, student_name, ghname, []) write_string_to_file(f'students/{student_login}', s.toJSON()) save_encrypted(f'students/{student_login}-achievements', student_key, '[]')
def new_user(): student_login = '' while student_login == '': student_login = input('login insper: ').strip() student_key = create_key(f'students/{student_login}.key') student_name = input('nome completo: ') student_avatar = input('imagem de avatar: ') s = Student(student_login, student_name, student_avatar, []) write_string_to_file(f'students/{student_login}', s.toJSON()) save_encrypted(f'students/{student_login}-achievements', student_key, '[]')
def get_num_unique_combos(data_dir, keys): """ Get number of occurrences for a property combination. """ for input_file in glob.glob('%s/*.*' % data_dir): with open(input_file, 'rb') as f: data=pickle.load(f) grouped_by_props=defaultdict(list) for doc_id, doc_data in data.items(): for part_id, part_props in doc_data.items(): k=utils.create_key(part_props, keys) grouped_by_props[k].append(part_id) print(input_file) print('Number of unique combinations:', len(grouped_by_props.keys())) print('Distribution', json.dumps(utils.get_distribution(grouped_by_props), sort_keys=True))
def create_keys(self): """Create a new pair of private and public keys""" try: # If we've already created a private key before, import it # Otherwise, create it with open(self.key_path, "r") as f: private_key = RSA.import_key(f.read(), passphrase=self.__password) public_key = private_key.publickey() except IOError: private_key = create_key() public_key = private_key.publickey() with open(self.key_path, "wb") as f: f.write( private_key.export_key("PEM", passphrase=self.__password)) self.__private_key = parse_key(private_key) self.__public_key = parse_key(public_key)
def analyze_distinguishability_of_props(data_dir, keys): """ Analyze how often can two entity pairs be distinguished based on properties, and splits this into: distinguishable, indistinguishable, and sufficient to distinguish. """ input_sets={} for input_file in glob.glob('%s/*.*' % data_dir): with open(input_file, 'rb') as f: data=pickle.load(f) grouped_by_name=defaultdict(dict) for doc_id, doc_data in data.items(): for part_id, part_props in doc_data.items(): if 'Name' not in part_props.keys() or not part_props['Name'].strip(): continue name=part_props['Name'].strip() k=utils.create_key(part_props, keys) grouped_by_name[name][part_id]=k #print(input_file) filename=utils.get_filename(input_file) input_sets[filename]=utils.obtain_sets(grouped_by_name) return input_sets
def scrape_from_2016(soup): all_org_data = {} orgs = soup.findAll('li', attrs={'class': 'organization-card__container'}) for ind, org in enumerate(orgs): print("DEBUG: Scraped details for {}/{} orgs".format(ind, len(orgs)), end="\r") link = org.find('a', attrs={'class': 'organization-card__link'}) org_name = org['aria-label'] org_link = ROOT_URL + link['href'] response = requests.get(org_link) html = response.content soup = BeautifulSoup(html, 'html.parser') tech_tags = soup.findAll( 'li', attrs={'class': 'organization__tag organization__tag--technology'}) technologies = [] for tag in tech_tags: technologies.append(tag.text.replace(" ", '')) topic_tags = soup.findAll( 'li', attrs={'class': 'organization__tag organization__tag--category'}) category = topic_tags[0].text.replace('\n', '') topic_tags = soup.findAll( 'li', attrs={'class': 'organization__tag organization__tag--topic'}) topics = [] for tag in topic_tags: topics.append(tag.text) all_org_data[create_key(org_name)] = { "name": org_name, "technologies": ' | '.join(technologies), "topics": ' | '.join(topics), "category": category } return all_org_data
def normalize(self, **other_params): cherrypy.response.headers['Content-Type'] = "application/json" params = {} if cherrypy.request.method == "POST": params = cherrypy.request.json error_message = str() error_flag = False job_description = "" batch_size = 0 total_time = time.time() if norm_job.JOBS_PARAMETER not in params: error_flag = True error_message = configurator.commons.MALFORMED_REQUEST_ERROR_MESSAGE else: jobs = params[norm_job.JOBS_PARAMETER] job_array = [] skill_array = [] responses = [] bypass_array = [] batch_size = len(jobs) for job in jobs: try: filtered_title = job[norm_job.JOB_TITLE_PARAMETER] if "instead of" in filtered_title.lower(): filtered_title = filtered_title[:filtered_title.lower( ).find("instead of")].strip() filtered_title = create_key(filtered_title, self.city_list, self.state_list, self.state_codes) job[norm_job.JOB_TITLE_PARAMETER] = filtered_title except: filtered_title = "" job_description = "" if norm_job.JOB_DESCRIPTION_PARAMETER in job: job_description = job[norm_job.JOB_DESCRIPTION_PARAMETER] title_ngrams = find_all_ngrams_upto(filtered_title.lower(), 4) if title_ngrams.intersection(self.driver_ngrams_set): bypass_array.append(1) else: job_array.append((filtered_title, job_description)) bypass_array.append(0) imp_skills = set() if job_description: sentences = norm_job.sent_detector.tokenize( job_description) for sentence in sentences: lower_sentence = sentence.lower() sentence_n_grams = find_all_ngrams_upto( lower_sentence, norm_job.ngram_limit) imp_skills.update( sentence_n_grams.intersection( norm_job.universal_skill_set)) skill_array.append(imp_skills) start_time = time.time() prediction_array = self.model.predict(job_array) root.info( "Context Free classification for {0} points done in {1}s". format(len(prediction_array), time.time() - start_time)) del job_array # root.info(prediction_array) start_time = time.time() for point_index, selector_value in enumerate(bypass_array): if selector_value: soc_codes_with_conf = self.driver_soc_codes else: soc_codes_with_conf = prediction_array.pop(0) soc_codes = [ soc[0] for soc in sorted( soc_codes_with_conf, key=lambda k: k[1], reverse=True) ] try: job_title = jobs[point_index][norm_job.JOB_TITLE_PARAMETER] if "instead of" in job_title.lower(): job_title = job_title[:job_title.lower(). find("instead of")].strip() except: error_flag = True error_message = configurator.commons.MALFORMED_REQUEST_ERROR_MESSAGE if not error_flag: response_json = {} response_json["index"] = point_index response_json["clean_original_title"] = format_skills( jobs[point_index][norm_job.JOB_TITLE_PARAMETER]) response_json["soc_code"] = '' response_json["confidence"] = 0 response_json["closest_lay_title"] = '' response_json["major_group_string"] = '' response_json["skills"] = list(skill_array[point_index]) if not soc_codes: ''' The given job posting could not be normalized using our standard algorithm. We should use the soc_hint parameter present here to see if we can find a nearby title in the given hint SOC code.''' if norm_job.SOC_HINT_PARAMETER in jobs[point_index]: soc_hint = jobs[point_index][ norm_job.SOC_HINT_PARAMETER] if soc_hint in self.soc_mapping: ''' This is a valid SOC Code ''' associated_soc_codes = self.soc_mapping[ soc_hint] soc_codes = list(associated_soc_codes) root.info( "Hinted {} hence, Comparing Against Codes {}" .format(soc_hint, soc_codes)) else: ''' This is an invalid SOC Code and we can't do much about it. ''' root.info( "No matching SOC Code found in soc_hint {}. Cannot normalize." .format(soc_hint)) if soc_codes: key_string = filter_chain.apply( convert_encoding(job_title), is_title=True)[1] closest_lay_title_tuple = norm_job.fetch_closest_lay_title( self.lay_title_list, self.soc_lay_title_token_list, soc_codes, key_string, "") major_group_string = configurator.commons.DEFAULT_MAJOR_GROUP_STRING if closest_lay_title_tuple[1] in self.soc_master_dict: major_group_string = self.soc_master_dict[ closest_lay_title_tuple[1]][ 'major_group_string'] lay_title = convert_encoding( closest_lay_title_tuple[0]) if lay_title in self.lay_title_dict: lay_title = self.lay_title_dict[lay_title] if lay_title in self.similar_title_dict: lay_title = self.similar_title_dict[lay_title] response_json["soc_code"] = closest_lay_title_tuple[1] response_json["confidence"] = int( dict(soc_codes_with_conf)[ closest_lay_title_tuple[1]]) response_json['top_soc'] = closest_lay_title_tuple[2] response_json["closest_lay_title"] = lay_title response_json[ "major_group_string"] = major_group_string else: response_json = { "error_code": configurator.commons.MALFORMED_REQUEST_ERROR_STATUS, "message": error_message } responses.append(response_json) error_flag = False if (point_index + 1) % 1000 == 0: root.info("{0} points done in {1}s".format( point_index, time.time() - start_time)) start_time = time.time() responses_object = {"normalized_jobs": responses} if error_flag: cherrypy.response.status = configurator.commons.MALFORMED_REQUEST_ERROR_STATUS responses_object = { "error_code": configurator.commons.MALFORMED_REQUEST_ERROR_STATUS, "message": error_message } root.info("{0} points done in {1}s".format(batch_size, time.time() - total_time)) return responses_object
def image_iterator(url, uri, region, size, rotation, quality, format, oversample): tile_size = get_setting('tile_size', 512) # optimistic first attempt at avoiding lookup by fixing size with trailing comma if match(r'^\d+,$', size) and match(r'^\d+,\d+,\d+,\d+$', region): x, y, w, h = [ int(x) for x in match(r'(\d+),(\d+),(\d+),(\d+)', region).groups() ] s = int(match(r'(\d+),', size).group(1)) size = size + str(int(s * h / w)) # optimistic attempt at avoiding lookup by fixing max size if match(r'^\d+,\d+,\d+,\d+$', region) and match(r'^\d+,\d+$', size): x, y, w, h = [ int(x) for x in match(r'(\d+),(\d+),(\d+),(\d+)', region).groups() ] sx, sy = [int(x) for x in match(r'(\d+),(\d+)', size).groups()] if (w, h) == (sx, sy): size = 'max' # short-circuit full-size files that resolve to disk if url and url.startswith( 'file:///' ) and size == 'max' and region == 'full' and rotation == '0' and quality == 'default' and url.endswith( format): with open(url[7:], mode='rb') as f: b = f.read(100 * 1024) while len(b) != 0: yield b b = f.read(100 * 1024) return # exact match? key = create_key(uri, region, size, rotation, quality, format) if key in cache: yield from cache.iter_get(key) return # get info and cache / tile file if necessary if uri in cache: i = loads(cache.get(uri)) else: with cache.lock(uri + ':worker'): # check again after recieving lock if uri in cache: i = loads(cache.get(uri)) else: i = get_info(url, uri) # tile everything except JPEG2000 if i['format'] != 'JPEG2000': im = get_image(url, uri) ingest(im, url, uri) # match for normalized key? nkey = create_key(uri, region, size, rotation, quality, format, width=i['width'], height=i['height'], tile_size=tile_size, normalize=True) if nkey in cache: yield from cache.iter_get(nkey) return # quick hack for JPEG2000 files that resolve to disk if get_setting('opj_decompress') and url.startswith( 'file:///') and i['format'] == 'JPEG2000': image = opj_decompress(i, url[7:], region, size, tile_size=tile_size, oversample=oversample) image = rotate(image, float(rotation)) image = do_quality(image, quality) b = BytesIO() icc_profile = image.info.get("icc_profile") image.save(b, quality=90, icc_profile=icc_profile, progressive=True, format='jpeg' if format == 'jpg' else format) # this can get expensive! if get_setting('cache_all', False): print('warning: caching arbitrary sized image (%s)' % nkey, flush=True) save_to_cache(nkey, image) elif is_tile(i, image): save_to_cache(nkey, image) yield b.getvalue() return # quick hack for JPEG2000 when cached originals allowed if get_setting('opj_decompress') and get_setting('cache_original'): okey = uri + ':original' if okey not in cache: with cache.lock(uri + ':worker'): if okey not in cache: # calling get image will cache it get_image(url, uri) loc = join(*cache.get_location(okey)) image = opj_decompress(i, loc, region, size, tile_size=tile_size, oversample=oversample) image = rotate(image, float(rotation)) image = do_quality(image, quality) b = BytesIO() icc_profile = image.info.get("icc_profile") image.save(b, quality=90, icc_profile=icc_profile, progressive=True, format='jpeg' if format == 'jpg' else format) # this can get expensive! if get_setting('cache_all', False) or is_tile(i, image): print('warning: caching arbitrary sized image (%s)' % nkey, flush=True) save_to_cache(nkey, image) yield b.getvalue() return # image is cached, just not in the right rotation, quality or format? key = create_key(uri, region, size, '0', 'default', config['settings']['cache_format']) if key in cache: image = Image.open(BytesIO(cache.get(key))) elif url.startswith('file:///'): image = get_image(url, uri) image = crop(image, region) image = resize(image, size) else: print('doing actual work for uri: ' + uri, flush=True) # image is cached, but size is wrong? # TODO: use optimal size rather than 'max' key = create_key(uri, region, 'max', '0', 'default', config['settings']['cache_format']) if key in cache: image = resize(Image.open(BytesIO(cache.get(key))), size) else: # requested image is also cropped # TODO: use optimal size rather than 'max' key = create_key(uri, 'full', 'max', '0', 'default', config['settings']['cache_format']) if key in cache: image = Image.open(BytesIO(cache.get(key))) image = crop(image, region) image = resize(image, size) else: raise Exception('Stitching image from tiles not supported yet') image = rotate(image, float(rotation)) image = do_quality(image, quality) b = BytesIO() icc_profile = image.info.get("icc_profile") image.save(b, quality=90, icc_profile=icc_profile, progressive=True, format='jpeg' if format == 'jpg' else format) # this can get expensive! if get_setting('cache_all', False): print('warning: caching arbitrary sized image (%s)' % nkey, flush=True) save_to_cache(nkey, image) yield b.getvalue()
def test_accusation(): # Valid random accusation a = Accusation.get_random()["accusation"] assert a.is_valid() == True # Invalid random accusation a = Accusation.get_random(valid=False)["accusation"] assert a.is_valid() == False judges = [ID.get_random()["id"] for _ in range(MIN_JUDGES)] rule = { "content": "You shall not kill", "sentence": "Some really bad thing", "reward": { "value": 1000, "currency": "Nano" } } rules = [rule for _ in range(MIN_RULES)] expire = datetime.datetime.now() + datetime.timedelta(days=1) contract = Contract(userid, rules, judges, expire) contract.sign(key) accused = ID("Murray Rothbard", parsed_pubkey) # Should be valid as well a = Accusation(userid, accused, contract) a.sign(key) assert a.is_valid() == True with pytest.raises(TypeError): a = Accusation("User", accused, contract) with pytest.raises(TypeError): a = Accusation(userid, "Accused", contract) with pytest.raises(TypeError): a = Accusation(userid, accused, {"content": "..."}) content = hash_content( { "username": "******", "public_key": parsed_pubkey }, HASH_DIFFICULTY - 1, NONCE_LIMIT) content["hash_value"] = content["hash_value"].replace("0", "a") invalid_id = ID(**content) # Invalid sender's ID a = Accusation(invalid_id, accused, contract) a.sign(key) assert a.is_valid() == False # Invalid accused's ID a = Accusation(userid, invalid_id, contract) a.sign(key) assert a.is_valid() == False # Unmatching key a = Accusation(userid, accused, contract) a.sign(create_key()) assert a.is_valid() == False # Invalid contract a = Accusation(userid, accused, Contract.get_random(valid=False)["contract"]) a.sign(key) assert a.is_valid() == False
def test_verdict(): # Valid random verdict v = Verdict.get_random()["verdict"] assert v.is_valid() == True # Invalid random verdict v = Verdict.get_random(valid=False)["verdict"] assert v.is_valid() == False judges = [ID.get_random()["id"] for _ in range(MIN_JUDGES)] rule = { "content": "You shall not kill", "sentence": "Some really bad thing", "reward": { "value": 1000, "currency": "Nano" } } rules = [rule for _ in range(MIN_RULES)] expire = datetime.datetime.now() + datetime.timedelta(days=1) contract = Contract(userid, rules, judges, expire) contract.sign(key) accused = ID("Hercule Poirot", parsed_pubkey) accusation = Accusation(userid, accused, contract) accusation.sign(key) sentence = "Must be executed" description = "Because I say so" # Should be valid as well v = Verdict(userid, accusation, sentence, description) v.sign(key) assert v.is_valid() == True with pytest.raises(TypeError): v = Verdict("User", accusation, sentence, description) with pytest.raises(TypeError): v = Verdict(userid, {"content": "..."}, sentence, description) with pytest.raises(TypeError): v = Verdict(userid, accusation, False, description) with pytest.raises(TypeError): v = Verdict(userid, accusation, sentence, 76) content = hash_content( { "username": "******", "public_key": parsed_pubkey }, HASH_DIFFICULTY - 1, NONCE_LIMIT) content["hash_value"] = content["hash_value"].replace("0", "a") invalid_id = ID(**content) # Invalid sender's ID v = Verdict(invalid_id, accusation, sentence, description) v.sign(key) assert v.is_valid() == False # Unmatching key v = Verdict(userid, accusation, sentence, description) v.sign(create_key()) assert v.is_valid() == False # Invalid accusation v = Verdict(userid, Accusation.get_random(valid=False)["accusation"], sentence, description) v.sign(key) assert v.is_valid() == False # No sentence at all v = Verdict(userid, accusation, "", description) v.sign(key) assert v.is_valid() == False # Sentence with more chars than the allowed v = Verdict(userid, accusation, "c" * (SENTECE_CHAR_LIMIT + 1), description) v.sign(key) assert v.is_valid() == False # Description with more chars than the allowed v = Verdict(userid, accusation, sentence, "c" * (DESCRIPTION_CHAR_LIMIT + 1)) v.sign(key) assert v.is_valid() == False
def test_appeal(): # Valid random appeal a = Appeal.get_random()["appeal"] assert a.is_valid() == True # Invalid random appeal a = Appeal.get_random(valid=False)["appeal"] assert a.is_valid() == False judges = [ID.get_random()["id"] for _ in range(MIN_JUDGES)] rule = { "content": "You shall not kill", "sentence": "Some really bad thing", "reward": { "value": 1000, "currency": "Nano" } } rules = [rule for _ in range(MIN_RULES)] expire = datetime.datetime.now() + datetime.timedelta(days=1) contract = Contract(userid, rules, judges, expire) contract.sign(key) accused = ID("Hercule Poirot", parsed_pubkey) accusation = Accusation(userid, accused, contract) accusation.sign(key) sentence = "Must be executed" description = "Because I say so" verdict = Verdict(userid, accusation, sentence, description) verdict.sign(key) # Valid hardcoded appeal a = Appeal(userid, verdict) a.sign(key) assert a.is_valid() == True with pytest.raises(TypeError): a = Appeal("User", verdict) with pytest.raises(TypeError): a = Appeal(userid, {"content": "..."}) content = hash_content( { "username": "******", "public_key": parsed_pubkey }, HASH_DIFFICULTY - 1, NONCE_LIMIT) content["hash_value"] = content["hash_value"].replace("0", "a") invalid_id = ID(**content) # Invalid sender's ID a = Appeal(invalid_id, verdict) a.sign(key) assert a.is_valid() == False # Unmatching key a = Appeal(userid, verdict) a.sign(create_key()) assert a.is_valid() == False invalid_verdict = Verdict(userid, accusation, "", description) invalid_verdict.sign(key) # Invalid verdict a = Appeal(userid, invalid_verdict) a.sign(key) assert a.is_valid() == False
def test_contract(): # Valid random contract c = Contract.get_random()["contract"] assert c.is_valid() == True # Invalid random contract c = Contract.get_random(valid=False)["contract"] assert c.is_valid() == False judges = [ID("Agatha Christie", parsed_pubkey) for _ in range(MIN_JUDGES)] rule = { "content": "You shall not kill", "sentence": "Some really bad thing", "reward": { "value": 1000, "currency": "Nano" } } rules = [rule for _ in range(MIN_RULES)] expire = datetime.datetime.now() + datetime.timedelta(days=1) # Should be valid as well c = Contract(userid, rules, judges, expire) c.sign(key) assert c.is_valid() == True content = hash_content( { "username": "******", "public_key": parsed_pubkey }, HASH_DIFFICULTY - 1, NONCE_LIMIT) content["hash_value"] = content["hash_value"].replace("0", "a") invalid_id = ID(**content) # Invalid ID c = Contract(invalid_id, rules, judges, expire) c.sign(key) assert c.is_valid() == False # Unmatching key c = Contract(userid, rules, judges, expire) c.sign(create_key()) assert c.is_valid() == False # No judges c = Contract(userid, rules, [], expire) c.sign(key) assert c.is_valid() == False # No rules c = Contract(userid, [], judges, expire) c.sign(key) assert c.is_valid() == False # Sender as judge c = Contract(userid, rules, [userid], expire) c.sign(key) assert c.is_valid() == SENDER_CAN_JUDGE # Repeated judges c = Contract(userid, rules, [judges[0] for _ in range(MAX_JUDGES)], expire) c.sign(key) assert c.is_valid() == False expired = datetime.datetime.now() - datetime.timedelta(days=1) c = Contract(userid, rules, judges, expired) c.sign(key) assert c.is_valid() == False
def make_key(self): """ Create a key. """ hashable = json.dumps(self.key_basis()) self.redis_key = create_key(hashable, self.cache_type)
import sys import os sys.path.append(os.path.dirname(os.path.realpath(__file__)) + "/../src") from config import id_config from utils import create_key, parse_key, hash_content from identity import ID HASH_DIFFICULTY = id_config["hash_difficulty"] NONCE_LIMIT = id_config["nonce_limit"] USERNAME_LIMIT = id_config["username_char_limit"] key = create_key() public_key = key.publickey() parsed_pubkey = parse_key(public_key) def test_ids(): # Verify if the random contract is valid assert ID.get_random()["id"].is_valid() == True assert ID.is_id_valid(ID.get_random()["id"].to_dict()) == True # Verify if the random contract is not valid (when valid == False) assert ID.get_random(valid=False)["id"].is_valid() == False assert ID.is_id_valid(ID.get_random(valid=False)["id"].to_dict()) == False # Should be valid content = hash_content( {