Synnefo

# Copyright (C) 2009 by Michael Fogleman

# Permission is hereby granted, free of charge, to any person obtaining a copy

# of this software and associated documentation files (the "Software"), to deal

# in the Software without restriction, including without limitation the rights

# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

# copies of the Software, and to permit persons to whom the Software is

# furnished to do so, subject to the following conditions:

# The above copyright notice and this permission notice shall be included in

# all copies or substantial portions of the Software.

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

Python implementation for generating Tiny URL- and bit.ly-like URLs.

collisions will occur.

improve the results of the algorithm.

bits are reversed.  Any bits higher than BLOCK_SIZE will remain as is.

be converting your integer to a different base.

integer is not used twice, the same short URL will not be generated twice.

parameter allows you to pad the URL if you want it to be a specific length.

Sample Usage:

>>> print key

12

and decode_url methods.

Author: Michael Fogleman

DEFAULT_BLOCK_SIZE = 24

MIN_LENGTH = 5

class UrlEncoder(object):

    def __init__(self, alphabet=DEFAULT_ALPHABET, block_size=DEFAULT_BLOCK_SIZE):

        self.alphabet = alphabet

        self.mask = (1 << block_size) - 1

        self.mapping = range(block_size)

        self.mapping.reverse()

    def encode_url(self, n, min_length=MIN_LENGTH):

        return self.enbase(self.encode(n), min_length)

    def decode_url(self, n):

        return self.decode(self.debase(n))

    def encode(self, n):

        return (n & ~self.mask) | self._encode(n & self.mask)

    def _encode(self, n):

        result = 0

        for i, b in enumerate(self.mapping):

            if n & (1 << i):

                result |= (1 << b)

        return result

    def decode(self, n):

        return (n & ~self.mask) | self._decode(n & self.mask)

    def _decode(self, n):

        result = 0

        for i, b in enumerate(self.mapping):

            if n & (1 << b):

                result |= (1 << i)

        return result

    def enbase(self, x, min_length=MIN_LENGTH):

        result = self._enbase(x)

        padding = self.alphabet[0] * (min_length - len(result))

        return '%s%s' % (padding, result)

    def _enbase(self, x):

        n = len(self.alphabet)

        if x < n:

            return self.alphabet[x]

        return self._enbase(x / n) + self.alphabet[x % n]

    def debase(self, x):

        n = len(self.alphabet)

        result = 0

DEFAULT_ENCODER = UrlEncoder()

def encode(n):

    return DEFAULT_ENCODER.encode(n)

def decode(n):

    return DEFAULT_ENCODER.decode(n)

def enbase(n, min_length=MIN_LENGTH):

    return DEFAULT_ENCODER.enbase(n, min_length)

def debase(n):

    return DEFAULT_ENCODER.debase(n)

def encode_url(n, min_length=MIN_LENGTH):

    return DEFAULT_ENCODER.encode_url(n, min_length)

def decode_url(n):

    return DEFAULT_ENCODER.decode_url(n)