def _address(key): addresses = llist(mongo.db.address.find({'address': key})) address = latest(addresses) if not address: return abort(404) street = latest(mongo.db.street.find({'street': address['street']})) children = sorted_naturally( llist(mongo.db.address.find({'parent-address': key}))) parents = address_parents(address) addresses = addresses + children + parents postcode = mongo.db['address-postcode'].find_one({'address': key})['postcode'] return render_template("address.html", address=address, addresses=addresses, street=street, postcode=postcode, uprn=decode(key), parents=parents, children=children)
def is_like_cid(cid): """ Raises ValueError if the cid given on input does not look like a genuine CID produced by zato.common.util.new_cid """ if not isinstance(cid, string_types): raise ValueError( 'CID `{}` should be string like instead of `{}`'.format( cid, type(cid))) len_given = len(cid) len_expected = CID_LENGTH + 1 # CID_LENGTH doesn't count 'K' in if len_given != len_expected: raise ValueError( 'CID `{}` should have length `{}` instead of `{}`'.format( cid, len_expected, len_given)) if not cid.startswith('K'): raise ValueError('CID `{}` should start with `K`'.format(cid)) value = decode(cid[1:]) if (value >> 128) != 0: raise ValueError('There aren\'t 128 bits in CID `{}`'.format(value)) return True
def get_object(self, queryset=None): key = self.kwargs.get(self.pk_url_kwarg, None) try: pk = base32_crockford.decode(key) except ValueError: raise Http404 return get_object_or_404(Post.objects.published(), pk=pk)
def revert_doi(doi): ''' Returns offset and internal ID belonging to a DOI that was generated with generate_doi(). Args: doi (str): The DOI Returns: {"prefix" (str): the prefix, "offset" (int): the offset, "intid" (int): internal ID} ''' try: prefix, encoded = doi.split('/') except ValueError: # assuming prefix was omitted encoded = doi prefix = None i = b32.decode(encoded, checksum=True) n = int(i / 37) c = i % 37 intid = int(c + n * 32) batch = int(intid / 2e6) offset = int(batch * 2e6) intid = intid - offset return {'prefix': prefix, 'offset': offset, 'intid': intid}
def is_like_cid(cid): """ Raises ValueError if the cid given on input does not look like a genuine CID produced by zato.common.util.new_cid """ if not isinstance(cid, string_types): raise ValueError('CID `{}` should be string like instead of `{}`'.format(cid, type(cid))) len_given = len(cid) len_expected = CID_LENGTH + 1 # CID_LENGTH doesn't count 'K' in if len_given != len_expected: raise ValueError('CID `{}` should have length `{}` instead of `{}`'.format(cid, len_expected, len_given)) if not cid.startswith('K'): raise ValueError('CID `{}` should start with `K`'.format(cid)) value = decode(cid[1:]) if(value >> 128) != 0: raise ValueError('There aren\'t 128 bits in CID `{}`'.format(value)) return True
def run(cls, _input: Decodable, **kwargs) -> Optional[bytes]: """Decodes Base32 encoded bytes-like object or ASCII `data` string using the chars set and rules as defined by Douglas Crockford. See https://www.crockford.com/base32.html :param _input: Base64 encoded (bytes) string :param kwargs: Arbitrary keyword arguments :return: `None` if `data` couldn't be decoded, else decoded byte string """ try: if not isinstance(_input, str): _input = str_from_bytes(_input) if (re.search(r"[^0123456789ABCDEFGHJKMNPQRSTVWXYZ]", _input.upper()) is not None): return None decoded = base32_crockford.decode(_input, strict=True) return decoded.to_bytes((decoded.bit_length() + 7) // 8, byteorder="big") except: return None
def redirect(request, key): """ Given the short URL key, update the statistics and redirect the user to the destination URL. """ try: alias = ShortURLAlias.objects.get(alias=key.lower()) key_id = alias.redirect_id except ShortURLAlias.DoesNotExist: try: key_id = base32_crockford.decode(key) except ValueError as e: logger.warning("Error decoding redirect: %s" % e) raise Http404 redirect = get_object_or_404(ShortURL, pk=key_id) ShortURL.objects.increment_hits(redirect.pk) params = request.GET.dict() if redirect.is_tracking: return HttpResponsePermanentRedirect(redirect.target_url(params=params)) else: return HttpResponseRedirect(redirect.target_url(params=params))
def redirect(request, key): """ Given the short URL key, update the statistics and redirect the user to the destination URL. """ try: alias = ShortURLAlias.objects.get(alias=key.lower()) key_id = alias.redirect_id except ShortURLAlias.DoesNotExist: try: key_id = base32_crockford.decode(key) except ValueError as e: logger.warning("Error decoding redirect: %s" % e) raise Http404 redirect = get_object_or_404(ShortURL, pk=key_id) ShortURL.objects.increment_hits(redirect.pk) params = request.GET.dict() if redirect.is_tracking: return HttpResponsePermanentRedirect( redirect.target_url(params=params)) else: return HttpResponseRedirect(redirect.target_url(params=params))
def test_base32_crockford(input_int): assert base32_crockford.decode( base32_crockford.encode(input_int)) == input_int
def from_str(cls, lid_str) -> "LID": ts_repr, rand_repr = lid_str.split("-") milliseconds = base32_crockford.decode(ts_repr) rand = base32_crockford.decode(rand_repr) return cls((milliseconds << 22) | rand)
def str26_to_int( string: str ) -> int: ''' In: string, 26char encoding of uuid Returns: Int of uuid ''' return decode( string )
def test_decode_strict(self): self.assertRaises(ValueError, b32.decode, '16j', strict=True) self.assertEqual(b32.decode('16J', strict=True), 1234)
def test_decode_checksum(self): self.assertEqual(b32.decode('16JD', checksum=True), 1234)
def test_decode_unicode(self): self.assertEqual(b32.decode(u'16J'), 1234)
def _school(urn): if request.method == 'POST': mongo.db['school-address'].find_one_and_update({'school': urn}, { '$set': { 'school': urn, 'address': request.form['address'], 'address-match': 'byhand' } }, upsert=True) return redirect("/school/" + urn, code=303) edubase = latest(mongo.db.edubase.find({'URN': urn})) if not edubase: return abort(404) key = uprn = postcode = '' address = street = {} addresses = parents = children = streets = [] key = '' doc = mongo.db['school-address'].find_one({'school': urn}) if doc: key = doc['address'] if key != '': key = key.split(";")[0] uprn = decode(key) addresses = llist(mongo.db.address.find({'address': key})) address = latest(addresses) if address: street = latest(mongo.db.street.find({'street': address['street']})) children = sorted_naturally( llist(mongo.db.address.find({'parent-address': key}))) parents = address_parents(address) addresses = addresses + children + parents postcode = mongo.db['address-postcode'].find_one({'address': key})['postcode'] point = [] if edubase['Easting']: lat, lon = pyproj.transform(osgb36, wgs84, edubase['Easting'], edubase['Northing']) point = [lon, lat] addresses = addresses + llist( mongo.db.address.find({ 'point': SON([('$nearSphere', [lat, lon]), ('$maxDistance', 0.00004)]) })) streets = streets + llist( mongo.db.street.find({ 'point': SON([('$nearSphere', [lat, lon]), ('$maxDistance', 0.00004)]) })) guesses = {} ignore = ['the'] words = n7e(edubase['EstablishmentName'], ignore).split() words = words + [ 'school', 'academy', 'infant', 'junior', 'middle', 'college', 'jmi', 'campus' ] for a in addresses: if set(words).intersection(set(n7e(a['name'], ignore).split())): guesses[a['address'] + ":" + a['name']] = a guesses = [guesses[k] for k in sorted(guesses)] return render_template("school.html", edubase=edubase, guesses=guesses, point=point, address=address, addresses=addresses, streets=streets, street=street, postcode=postcode, uprn=uprn, parents=parents, children=children)