Пример #1
0
def generate_short_id():
    """ Short ID generator - v2: Shuffled XOR UUID1 """
    num = uuid1().int
    mask = (1 << 64) - 1
    result = (num ^ (num >> 1)) & 0x55555555555555555555555555555555
    result = ((mask & (result >> 64)) << 1) | (mask & result)
    return base62().encode(result)
Пример #2
0
def test_bases():
    b36 = base36()
    b52 = base52()
    b56 = base56()
    b58 = base58()
    b62 = base62()
    b94 = base94()
Пример #3
0
    def post(self):
        user = self.get_current_user()

        trip = dict()
        trip_fields = {
            'start_date': 'start_date',
            'end_date': 'end_date',
            'description': 'description',
            'place_id': 'place_id',
            'address': 'formatted_address',
            'locality': 'locality',
            'region': 'administrative_area_level_1',
            'county': 'administrative_area_level_2',
            'longitude': 'lng',
            'latitude': 'lat'
        }

        for key in trip_fields:
            trip[key] = self.get_argument(trip_fields[key], None)

        trip_uuid = simpleflake()
        trip['trip_id'] = base62().hash(trip_uuid, 12)

        trip['created_at'] = r.now()
        trip['updated_at'] = r.now()
        trip['creator_user_id'] = user['id']

        trip['geo'] = r.point(float(trip['longitude']),
                              float(trip['latitude']))

        r.table("trip").insert(trip).run()
        self.redirect("/")
Пример #4
0
  def post(self):
    user = self.get_current_user()

    trip = dict()
    trip_fields = {
      'start_date': 'start_date', 
      'end_date': 'end_date', 
      'description': 'description', 
      'place_id': 'place_id',
      'address': 'formatted_address',
      'locality': 'locality',
      'region': 'administrative_area_level_1',
      'county': 'administrative_area_level_2',
      'longitude': 'lng',
      'latitude': 'lat'
      }

    for key in trip_fields:
      trip[key] = self.get_argument(trip_fields[key], None)

    trip_uuid = simpleflake()
    trip['trip_id'] = base62().hash(trip_uuid, 12)

    trip['created_at'] = r.now()
    trip['updated_at'] = r.now()
    trip['creator_user_id'] = user['id']

    trip['geo'] = r.point(float(trip['longitude']), float(trip['latitude']))

    r.table("trip").insert(trip).run()
    self.redirect("/")
Пример #5
0
    def _get_short_string(string):
        sha = hashlib.sha384(string.encode())
        digest = sha.digest()
        for i in range(StringShortner.FOLDS):
            digest = StringShortner._fold_hex_series(digest)

        number = StringShortner._num_from_hex_series(digest)
        base62 = basehash.base62(length=StringShortner.STRING_LEN)
        return base62.hash(number)
Пример #6
0
def convert_short_id(n):
    """ Short ID converter - v1: Half Unshuffled UUID1 """
    x = (n ^ (n >> 1)) & 0x55555555555555555555555555555555
    x = (x | (x >> 1)) & 0x33333333333333333333333333333333
    x = (x | (x >> 2)) & 0x0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F
    x = (x | (x >> 4)) & 0x00FF00FF00FF00FF00FF00FF00FF00FF
    x = (x | (x >> 8)) & 0x0000FFFF0000FFFF0000FFFF0000FFFF
    x = (x | (x >> 16)) & 0x00000000FFFFFFFF00000000FFFFFFFF
    x = (x | (x >> 32)) & 0x0000000000000000FFFFFFFFFFFFFFFF
    return base62().encode(x)
Пример #7
0
def generate_short_id():
    """ Short ID generator - v1: Half Unshuffled UUID1 """
    n = uuid1().int
    x = (n ^ (n >> 1)) & 0x55555555555555555555555555555555
    x = (x | (x >> 1)) & 0x33333333333333333333333333333333
    x = (x | (x >> 2)) & 0x0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F
    x = (x | (x >> 4)) & 0x00FF00FF00FF00FF00FF00FF00FF00FF
    x = (x | (x >> 8)) & 0x0000FFFF0000FFFF0000FFFF0000FFFF
    x = (x | (x >> 16)) & 0x00000000FFFFFFFF00000000FFFFFFFF
    x = (x | (x >> 32)) & 0x0000000000000000FFFFFFFFFFFFFFFF
    return base62().encode(x)
Пример #8
0
def generate_urlcode(redirect_url):
    new_id = yield tornado.gen.Task(c.incr, settings.URL_CODE_ID_REDIS_NAME)
    code = basehash.base62().encode(new_id)

    # set redis cache
    yield tornado.gen.Task(c.sadd, settings.URL_CODE_SET_NAME, code)
    yield tornado.gen.Task(c.set,
                           settings.URL_CODE_REDIS_BASE_NAME.format(code=code),
                           redirect_url)

    raise tornado.gen.Return(code)
Пример #9
0
    def post(self):
        user = self.get_current_user()

        event = dict()
        event_fields = [
            'title', 'start_date', 'end_date', 'start_time', 'end_time',
            'description', 'website'
        ]

        venue = dict()
        venue_fields = [
            'foursquare_id', 'name', 'address', 'locality', 'region',
            'postal_code', 'longitude', 'latitude'
        ]

        for key in event_fields:
            event[key] = self.get_argument(key, None)

        for key in venue_fields:
            venue[key] = self.get_argument(key, None)

        event_uuid = simpleflake()
        event['event_id'] = base62().hash(event_uuid, 12)

        venue_uuid = simpleflake()
        venue['venue_id'] = base62().hash(venue_uuid, 12)
        event['venue_id'] = venue['venue_id']

        event['created_at'] = r.now()
        event['updated_at'] = r.now()
        event['creator_user_id'] = user['id']

        venue['geo'] = r.point(float(venue['longitude']),
                               float(venue['latitude']))
        venue['created_at'] = r.now()
        venue['updated_at'] = r.now()
        venue['creator_user_id'] = user['id']

        r.table("event").insert(event).run()
        r.table("venue").insert(venue).run()
        self.redirect("/")
Пример #10
0
  def post(self):
    user = self.get_current_user()

    event = dict()
    event_fields = [
      'title', 'start_date', 'end_date', 'start_time', 'end_time', 'description', 
      'website'
      ]

    venue = dict()
    venue_fields = [
      'foursquare_id', 'name', 'address', 'locality', 'region', 'postal_code',
      'longitude', 'latitude'
      ]

    for key in event_fields:
      event[key] = self.get_argument(key, None)

    for key in venue_fields:
      venue[key] = self.get_argument(key, None)

    event_uuid = simpleflake()
    event['event_id'] = base62().hash(event_uuid, 12)

    venue_uuid = simpleflake()
    venue['venue_id'] = base62().hash(venue_uuid, 12)    
    event['venue_id'] = venue['venue_id']

    event['created_at'] = r.now()
    event['updated_at'] = r.now()
    event['creator_user_id'] = user['id']

    venue['geo'] = r.point(float(venue['longitude']), float(venue['latitude']))
    venue['created_at'] = r.now()
    venue['updated_at'] = r.now()
    venue['creator_user_id'] = user['id']

    r.table("event").insert(event).run()
    r.table("venue").insert(venue).run()
    self.redirect("/")
Пример #11
0
def asset_by_id(module, id):
    base = base62()
    encoded_id = base.encode(id)

    assets = '/myallegan/myallegan/static/assets/{}'.format(module)
    files = [f.name for f in scandir(assets) if f.is_file()]

    asset_ext = None
    for file_name in files:
        if encoded_id in file_name:
            asset_ext = file_name.split('.')[-1]

    if asset_ext:
        r = '/static/assets/{module}/{id}.{ext}'
        return r.format(module=module, id=encoded_id, ext=asset_ext)
    else:
        return None
Пример #12
0
def generate_short_id():
    """ Short ID generator - v0: Base62-Encoded UUID1 """
    return base62().encode(uuid1().int)
Пример #13
0
def convert_short_id(num):
    """ Short ID converter - v0: Base62-Encoded UUID1 """
    return base62().encode(num)
Пример #14
0
def b62encode(text: str) -> str:
    return base62().encode(int.from_bytes(text.encode(), byteorder='big'))
Пример #15
0
def url_safe_base62_uuid() -> str:
    return base62().encode(uuid.uuid4().int)
from sqlalchemy.dialects.postgresql.base import UUID
from sqlalchemy_utils import ScalarListType
from extensions import db
from basehash import base62
from ._base import ModelMixin

base62 = base62(6)


class ComparisonResponse(db.Model, ModelMixin):
    __tablename__ = "comparison_responses"

    response_hash = db.Column(db.String)

    data = db.Column(db.JSON)

    @classmethod
    def get_by_hash(cls, response_hash):
        response = ComparisonResponse.query.filter(cls.response_hash == response_hash).first()
        return response
Пример #17
0
import basehash
from flask import current_app as app
from path import Path
from sqlalchemy.types import Boolean, DateTime, Integer
from sqlalchemy.schema import Column
from datetime import datetime
from passgen.extensions import db, ma


_base62 = basehash.base62()


class Order(db.Model):

    """DB representation of a single pass order. Basically needed as a big
    counter."""

    __tablename__ = 'orders'

    id = Column(Integer, primary_key=True)
    range_from = Column(Integer, nullable=True)
    range_size = Column(Integer, nullable=True)
    ordered = Column(DateTime(timezone=False), nullable=False)
    finished = Column(DateTime(timezone=False), nullable=True)
    progress = Column(Integer, default=0, nullable=False)
    single_page = Column(Boolean, default=False, nullable=False)

    @classmethod
    def create(cls, size=1, single_page=False):
        """Create a new order, put it into the database and return the id"""
Пример #18
0
from nose.tools import raises

from basehash import base62


bh62 = base62()
bh6 = base62(6)
bh10 = base62(10)


def test_base62_encode_with_1234567890_1LY7VK():
    assert bh62.encode(1234567890) == '1LY7VK'


def test_base62_decode_with_1LY7VK_1234567890():
    assert bh62.decode('1LY7VK') == 1234567890


def test_base62_hash_with_1234567890_10_RERZ0NM8Na():
    assert bh10.hash(1234567890) == 'RERZ0NM8Na'


def test_base62_unhash_with_RERZ0NM8Na_1234567890():
    assert bh10.unhash('RERZ0NM8Na') == 1234567890


def test_base62_maximum_value_with_6_56800235583():
    assert bh6.maximum == 56800235583


@raises(ValueError)
Пример #19
0
from basehash import HASH_LENGTH, base36, base52, base56, base58, base62, base94

base36 = base36()
base52 = base52()
base56 = base56()
base58 = base58()
base62 = base62()
base94 = base94()

# Base encode an integer/long
print(base36.encode(200))
print(base52.encode(200))
print(base56.encode(200))
print(base58.encode(200))
print(base62.encode(200))
print(base94.encode(200))

# Base decode encoded string.
print(base36.decode('5K'))
print(base52.decode('3r'))
print(base56.decode('5a'))
print(base58.decode('4T'))
print(base62.decode('3E'))
print(base94.decode('#-'))

# Base hash an integer/long
# Takes an option param, length, which is defaulted to
# basehash.base.HASH_LENGTH
print(base36.hash(200))
print(base52.hash(200))
print(base56.hash(200))
Пример #20
0
from nose.tools import raises

from basehash import base62

bh62 = base62()
bh6 = base62(6)
bh10 = base62(10)


def test_base62_encode_with_1234567890_1LY7VK():
    assert bh62.encode(1234567890) == '1LY7VK'


def test_base62_decode_with_1LY7VK_1234567890():
    assert bh62.decode('1LY7VK') == 1234567890


def test_base62_hash_with_1234567890_10_RERZ0NM8Na():
    assert bh10.hash(1234567890) == 'RERZ0NM8Na'


def test_base62_unhash_with_RERZ0NM8Na_1234567890():
    assert bh10.unhash('RERZ0NM8Na') == 1234567890


def test_base62_maximum_value_with_6_56800235583():
    assert bh6.maximum == 56800235583


@raises(ValueError)
def test_base62_hash_fail_with_56800235584_6():
Пример #21
0
def convert_short_id(num):
    """ Short ID converter - v2: Shuffled XOR UUID1 """
    mask = (1 << 64) - 1
    result = (num ^ (num >> 1)) & 0x55555555555555555555555555555555
    result = ((mask & (result >> 64)) << 1) | (mask & result)
    return base62().encode(result)
Пример #22
0
def generate_short_id():
    """ Short ID generator - v4: Urandom """
    return base62().encode(unpack("<Q", urandom(8))[0])
Пример #23
0
from nose.tools import raises

from basehash import base62


base62 = base62()


def test_base62_encode_with_1234567890_1LY7VK():
    assert base62.encode(1234567890) == '1LY7VK'


def test_base62_decode_with_1LY7VK_1234567890():
    assert base62.decode('1LY7VK') == 1234567890


def test_base62_hash_with_1234567890_10_RERZ0NM8Na():
    assert base62.hash(1234567890, 10) == 'RERZ0NM8Na'


def test_base62_unhash_with_RERZ0NM8Na_1234567890():
    assert base62.unhash('RERZ0NM8Na') == 1234567890


def test_base62_maximum_value_with_6_56800235583():
    assert base62.maximum_value(6) == 56800235583


@raises(ValueError)
def test_base62_hash_fail_with_56800235584_6():
    assert base62.hash(56800235584, 6)