try:

            return unicode_.encode(enc)

        except UnicodeEncodeError:

            pass

    try:

        import chardet

        encoding = chardet.detect(unicode_)['encoding']

        if encoding is None:

            raise UnicodeEncodeError()

        return unicode_.encode(encoding)

    except (ImportError, UnicodeEncodeError):

        return unicode_.encode(to_encoding[0], 'replace')

    return safe_str

def remove_suffix(s, suffix):

    if s.endswith(suffix):

        s = s[:-1 * len(suffix)]

    return s

def remove_prefix(s, prefix):

    if s.startswith(prefix):

        s = s[len(prefix):]

    return s

def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):

    """

    Custom engine_from_config functions that makes sure we use NullPool for

    file based sqlite databases. This prevents errors on sqlite. This only

    applies to sqlalchemy versions < 0.7.0

    """

    import sqlalchemy

    from sqlalchemy import engine_from_config as efc

    import logging

    if int(sqlalchemy.__version__.split('.')[1]) < 7:

        # This solution should work for sqlalchemy < 0.7.0, and should use

        # proxy=TimerProxy() for execution time profiling

        from sqlalchemy.pool import NullPool

        url = configuration[prefix + 'url']

        if url.startswith('sqlite'):

            kwargs.update({'poolclass': NullPool})

        return efc(configuration, prefix, **kwargs)

    else:

        import time

        from sqlalchemy import event

        from sqlalchemy.engine import Engine

        log = logging.getLogger('sqlalchemy.engine')

        BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = xrange(30, 38)

        engine = efc(configuration, prefix, **kwargs)

        def color_sql(sql):

            COLOR_SEQ = "\033[1;%dm"

            COLOR_SQL = YELLOW

            normal = '\x1b[0m'

            return ''.join([COLOR_SEQ % COLOR_SQL, sql, normal])

        if configuration['debug']:

            #attach events only for debug configuration

            def before_cursor_execute(conn, cursor, statement,

                                    parameters, context, executemany):

                context._query_start_time = time.time()

                log.info(color_sql(">>>>> STARTING QUERY >>>>>"))

            def after_cursor_execute(conn, cursor, statement,

                                    parameters, context, executemany):

                total = time.time() - context._query_start_time

                log.info(color_sql("<<<<< TOTAL TIME: %f <<<<<" % total))

            event.listen(engine, "before_cursor_execute",

                         before_cursor_execute)

            event.listen(engine, "after_cursor_execute",

                         after_cursor_execute)

    return engine

def age(prevdate):

    """

    turns a datetime into an age string.

    :param prevdate: datetime object

    :rtype: unicode

    :returns: unicode words describing age

    """

    order = ['year', 'month', 'day', 'hour', 'minute', 'second']

    deltas = {}

    future = False

    if prevdate > now:

        now, prevdate = prevdate, now

        future = True

    for part in order:

    # Fix negative offsets (there is 1 second between 10:59:59 and 11:00:00,

    # not 1 hour, -59 minutes and -59 seconds)

    for num, length in [(5, 60), (4, 60), (3, 24)]:  # seconds, minutes, hours

        part = order[num]

        carry_part = order[num - 1]

        if deltas[part] < 0:

            deltas[part] += length

            deltas[carry_part] -= 1

    # Same thing for days except that the increment depends on the (variable)

    # number of days in the month

    month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

    if deltas['day'] < 0:

        if prevdate.month == 2 and (prevdate.year % 4 == 0 and

            (prevdate.year % 100 != 0 or prevdate.year % 400 == 0)):

            deltas['day'] += 29

        else:

            deltas['day'] += month_lengths[prevdate.month - 1]

        deltas['month'] -= 1

    if deltas['month'] < 0:

        deltas['month'] += 12

        deltas['year'] -= 1

    # Format the result

    fmt_funcs = {

        'year': lambda d: ungettext(u'%d year', '%d years', d) % d,

        'month': lambda d: ungettext(u'%d month', '%d months', d) % d,

        'day': lambda d: ungettext(u'%d day', '%d days', d) % d,

        'hour': lambda d: ungettext(u'%d hour', '%d hours', d) % d,

        'minute': lambda d: ungettext(u'%d minute', '%d minutes', d) % d,

        'second': lambda d: ungettext(u'%d second', '%d seconds', d) % d,

    }

    for i, part in enumerate(order):

        value = deltas[part]

        if value == 0:

            continue

        if i < 5:

            sub_part = order[i + 1]

            sub_value = deltas[sub_part]

        else:

            sub_value = 0

        if sub_value == 0:

            if future:

                return _(u'in %s') % fmt_funcs[part](value)

            else:

                return _(u'%s ago') % fmt_funcs[part](value)

        if future:

            return _(u'in %s and %s') % (fmt_funcs[part](value),

                fmt_funcs[sub_part](sub_value))

        else:

            return _(u'%s and %s ago') % (fmt_funcs[part](value),

                fmt_funcs[sub_part](sub_value))

    return _(u'just now')

def uri_filter(uri):

    """

    Removes user:password from given url string

    :param uri:

    :rtype: unicode

    :returns: filtered list of strings

    """

    if not uri:

        return ''

    proto = ''

    for pat in ('https://', 'http://'):

        if uri.startswith(pat):

            uri = uri[len(pat):]

            proto = pat

            break

    # remove passwords and username

    uri = uri[uri.find('@') + 1:]

    # get the port

    cred_pos = uri.find(':')

    if cred_pos == -1:

        host, port = uri, None

    else:

        host, port = uri[:cred_pos], uri[cred_pos + 1:]

    return filter(None, [proto, host, port])

def credentials_filter(uri):

    """

    Returns a url with removed credentials

import unittest

import datetime

import hashlib

import mock

from rhodecode.tests import *

proto = 'http'

TEST_URLS = [

    ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://marcink@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://marcink:pass@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://127.0.0.1:8080' % proto, ['%s://' % proto, '127.0.0.1', '8080'],

     '%s://127.0.0.1:8080' % proto),

    ('%s://domain.org' % proto, ['%s://' % proto, 'domain.org'],

     '%s://domain.org' % proto),

    ('%s://user:pass@domain.org:8080' % proto, ['%s://' % proto, 'domain.org',

                                                '8080'],

     '%s://domain.org:8080' % proto),

]

proto = 'https'

TEST_URLS += [

    ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://marcink@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://marcink:pass@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

    ('%s://127.0.0.1:8080' % proto, ['%s://' % proto, '127.0.0.1', '8080'],

     '%s://127.0.0.1:8080' % proto),

    ('%s://domain.org' % proto, ['%s://' % proto, 'domain.org'],

     '%s://domain.org' % proto),

    ('%s://user:pass@domain.org:8080' % proto, ['%s://' % proto, 'domain.org',

                                                '8080'],

     '%s://domain.org:8080' % proto),

]

class TestLibs(unittest.TestCase):

    def test_uri_filter(self):

        from rhodecode.lib.utils2 import uri_filter

        for url in TEST_URLS:

            self.assertEqual(uri_filter(url[0]), url[1])

    def test_credentials_filter(self):

        from rhodecode.lib.utils2 import credentials_filter

        for url in TEST_URLS:

            self.assertEqual(credentials_filter(url[0]), url[2])

    def test_str2bool(self):

        from rhodecode.lib.utils2 import str2bool

        test_cases = [

            ('t', True),

            ('true', True),

            ('y', True),

            ('yes', True),

            ('on', True),

            ('1', True),

            ('Y', True),

            ('yeS', True),

            ('Y', True),

            ('TRUE', True),

            ('T', True),

            ('False', False),

            ('F', False),

            ('FALSE', False),

            ('0', False),

            ('-1', False),

            ('', False), ]

        for case in test_cases:

            self.assertEqual(str2bool(case[0]), case[1])

    def test_mention_extractor(self):

        from rhodecode.lib.utils2 import extract_mentioned_users

        sample = (

            "@first hi there @marcink here's my email marcin@email.com "

            "@lukaszb check @one_more22 it pls @ ttwelve @D[] @one@two@three "

            "@MARCIN    @maRCiN @2one_more22 @john please see this http://org.pl "

            "@marian.user just do it @marco-polo and next extract @marco_polo "

            "user.dot  hej ! not-needed maril@domain.org"

        )

        s = sorted([

        'first', 'marcink', 'lukaszb', 'one_more22', 'MARCIN', 'maRCiN', 'john',

        'marian.user', 'marco-polo', 'marco_polo'

        ], key=lambda k: k.lower())

        self.assertEqual(s, extract_mentioned_users(sample))

    def test_age(self):

        from rhodecode.lib.utils2 import age

        n = datetime.datetime.now()

        self.assertEqual(age(n), u'just now')

    def test_age_in_future(self):

        from rhodecode.lib.utils2 import age

        n = datetime.datetime.now()

        self.assertEqual(age(n), u'just now')

        self.assertEqual(age(n + delt(seconds=1)), u'in 1 second')

        self.assertEqual(age(n + delt(seconds=60 * 2)), u'in 2 minutes')

        self.assertEqual(age(n + delt(hours=1)), u'in 1 hour')

        self.assertEqual(age(n + delt(hours=24)), u'in 1 day')

        self.assertEqual(age(n + delt(hours=24 * 5)), u'in 5 days')

    def test_tag_exctrator(self):

        sample = (

            "hello pta[tag] gog [[]] [[] sda ero[or]d [me =>>< sa]"

            "[requires] [stale] [see<>=>] [see => http://url.com]"

            "[requires => url] [lang => python] [just a tag]"

            "[,d] [ => ULR ] [obsolete] [desc]]"

        )

        from rhodecode.lib.helpers import desc_stylize

        res = desc_stylize(sample)

        self.assertTrue('<div class="metatag" tag="tag">tag</div>' in res)

        self.assertTrue('<div class="metatag" tag="obsolete">obsolete</div>' in res)

        self.assertTrue('<div class="metatag" tag="stale">stale</div>' in res)

        self.assertTrue('<div class="metatag" tag="lang">python</div>' in res)

        self.assertTrue('<div class="metatag" tag="requires">requires =&gt; <a href="/url">url</a></div>' in res)

        self.assertTrue('<div class="metatag" tag="tag">tag</div>' in res)

    def test_alternative_gravatar(self):

        from rhodecode.lib.helpers import gravatar_url

        _md5 = lambda s: hashlib.md5(s).hexdigest()

        def fake_conf(**kwargs):

            from pylons import config

            config['app_conf'] = {}

            config['app_conf']['use_gravatar'] = True

            config['app_conf'].update(kwargs)

            return config

        class fake_url():

            @classmethod

            def current(cls, *args, **kwargs):

                return 'https://server.com'

        with mock.patch('pylons.url', fake_url):

            fake = fake_conf(alternative_gravatar_url='http://test.com/{email}')

            with mock.patch('pylons.config', fake):

                    from pylons import url

                    assert url.current() == 'https://server.com'

                    grav = gravatar_url(email_address='test@foo.com', size=24)

                    assert grav == 'http://test.com/test@foo.com'

            fake = fake_conf(alternative_gravatar_url='http://test.com/{email}')

            with mock.patch('pylons.config', fake):

                grav = gravatar_url(email_address='test@foo.com', size=24)

                assert grav == 'http://test.com/test@foo.com'

            fake = fake_conf(alternative_gravatar_url='http://test.com/{md5email}')

            with mock.patch('pylons.config', fake):

                em = 'test@foo.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'http://test.com/%s' % (_md5(em))

            fake = fake_conf(alternative_gravatar_url='http://test.com/{md5email}/{size}')

            with mock.patch('pylons.config', fake):

                em = 'test@foo.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'http://test.com/%s/%s' % (_md5(em), 24)

            fake = fake_conf(alternative_gravatar_url='{scheme}://{netloc}/{md5email}/{size}')

            with mock.patch('pylons.config', fake):

                em = 'test@foo.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'https://server.com/%s/%s' % (_md5(em), 24)