``RhodeCode`` is a Pylons framework based Mercurial repository 

the ability to authenticate via LDAP or ActiveDirectory. RhodeCode also supports

simple API so it's easy integrable with existing systems.

1.3.0 (**XXXX-XX-XX**)

fixes

-----

1.2.0 (**2011-10-07**)

======================

news

----

VERSION = (1, 3, 0, 'beta')

__dbversion__ = 4 #defines current db version for migrations

from rhodecode.lib.compat import izip_longest, json

        except ValueError, e:

        except KeyError, e:

        except Exception, e:

        kwarglist = list(izip_longest(reversed(arglist), reversed(defaults),

        for arg, default in kwarglist:

        except JSONRPCError, e:

        except Exception, e:

            log.error('Encountered unhandled exception: %s' \

                      % traceback.format_exc())

from rhodecode.lib.compat import OrderedDict

from rhodecode.lib.compat import json

from rhodecode.lib.compat import OrderedDict

            #TODO: REMOVE THIS !!

            ################################

            import ipdb;ipdb.set_trace()

            print 'setting ipdb debuggin for rhodecode.controllers.files.FilesController.add'

            ################################

from rhodecode.lib.compat import json, OrderedDict

from rhodecode.lib.compat import OrderedDict

    return cs

from rhodecode.lib.compat import json, OrderedDict

# -*- coding: utf-8 -*-

"""

    rhodecode.lib.compat

    ~~~~~~~~~~~~~~~~~~~~

    Python backward compatibility functions and common libs

    :created_on: Oct 7, 2011

    :author: marcink

    :copyright: (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>    

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

#==============================================================================

# json

#==============================================================================

try:

    import json

except ImportError:

    import simplejson as json

#==============================================================================

# izip_longest

#==============================================================================

try:

    from itertools import izip_longest

except ImportError:

    import itertools

    def izip_longest(*args, **kwds): # noqa

        fillvalue = kwds.get("fillvalue")

        def sentinel(counter=([fillvalue] * (len(args) - 1)).pop):

            yield counter() # yields the fillvalue, or raises IndexError

        fillers = itertools.repeat(fillvalue)

        iters = [itertools.chain(it, sentinel(), fillers)

                    for it in args]

        try:

            for tup in itertools.izip(*iters):

                yield tup

        except IndexError:

            pass

#==============================================================================

# OrderedDict

#==============================================================================

# Python Software Foundation License

# XXX: it feels like using the class with "is" and "is not" instead of "==" and

# "!=" should be faster.

class _Nil(object):

    def __repr__(self):

        return "nil"

    def __eq__(self, other):

        if (isinstance(other, _Nil)):

            return True

        else:

            return NotImplemented

    def __ne__(self, other):

        if (isinstance(other, _Nil)):

            return False

        else:

            return NotImplemented

_nil = _Nil()

class _odict(object):

    """Ordered dict data structure, with O(1) complexity for dict operations

    that modify one element.

    Overwriting values doesn't change their original sequential order.

    """

    def _dict_impl(self):

        return None

    def __init__(self, data=(), **kwds):

        """This doesn't accept keyword initialization as normal dicts to avoid

        a trap - inside a function or method the keyword args are accessible

        only as a dict, without a defined order, so their original order is

        lost.

        """

        if kwds:

            raise TypeError("__init__() of ordered dict takes no keyword "

                            "arguments to avoid an ordering trap.")

        self._dict_impl().__init__(self)

        # If you give a normal dict, then the order of elements is undefined

        if hasattr(data, "iteritems"):

            for key, val in data.iteritems():

                self[key] = val

        else:

            for key, val in data:

                self[key] = val

    # Double-linked list header

    def _get_lh(self):

        dict_impl = self._dict_impl()

        if not hasattr(self, '_lh'):

            dict_impl.__setattr__(self, '_lh', _nil)

        return dict_impl.__getattribute__(self, '_lh')

    def _set_lh(self, val):

        self._dict_impl().__setattr__(self, '_lh', val)

    lh = property(_get_lh, _set_lh)

    # Double-linked list tail

    def _get_lt(self):

        dict_impl = self._dict_impl()

        if not hasattr(self, '_lt'):

            dict_impl.__setattr__(self, '_lt', _nil)

        return dict_impl.__getattribute__(self, '_lt')

    def _set_lt(self, val):

        self._dict_impl().__setattr__(self, '_lt', val)

    lt = property(_get_lt, _set_lt)

    def __getitem__(self, key):

        return self._dict_impl().__getitem__(self, key)[1]

    def __setitem__(self, key, val):

        dict_impl = self._dict_impl()

        try:

            dict_impl.__getitem__(self, key)[1] = val

        except KeyError, e:

            new = [dict_impl.__getattribute__(self, 'lt'), val, _nil]

            dict_impl.__setitem__(self, key, new)

            if dict_impl.__getattribute__(self, 'lt') == _nil:

                dict_impl.__setattr__(self, 'lh', key)

            else:

                dict_impl.__getitem__(

                    self, dict_impl.__getattribute__(self, 'lt'))[2] = key

            dict_impl.__setattr__(self, 'lt', key)

    def __delitem__(self, key):

        dict_impl = self._dict_impl()

        pred, _ , succ = self._dict_impl().__getitem__(self, key)

        if pred == _nil:

            dict_impl.__setattr__(self, 'lh', succ)

        else:

            dict_impl.__getitem__(self, pred)[2] = succ

        if succ == _nil:

            dict_impl.__setattr__(self, 'lt', pred)

        else:

            dict_impl.__getitem__(self, succ)[0] = pred

        dict_impl.__delitem__(self, key)

    def __contains__(self, key):

        return key in self.keys()

    def __len__(self):

        return len(self.keys())

    def __str__(self):

        pairs = ("%r: %r" % (k, v) for k, v in self.iteritems())

        return "{%s}" % ", ".join(pairs)

    def __repr__(self):

        if self:

            pairs = ("(%r, %r)" % (k, v) for k, v in self.iteritems())

            return "odict([%s])" % ", ".join(pairs)

        else:

            return "odict()"

    def get(self, k, x=None):

        if k in self:

            return self._dict_impl().__getitem__(self, k)[1]

        else:

            return x

    def __iter__(self):

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lh')

        while curr_key != _nil:

            yield curr_key

            curr_key = dict_impl.__getitem__(self, curr_key)[2]

    iterkeys = __iter__

    def keys(self):

        return list(self.iterkeys())

    def itervalues(self):

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lh')

        while curr_key != _nil:

            _, val, curr_key = dict_impl.__getitem__(self, curr_key)

            yield val

    def values(self):

        return list(self.itervalues())

    def iteritems(self):

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lh')

        while curr_key != _nil:

            _, val, next_key = dict_impl.__getitem__(self, curr_key)

            yield curr_key, val

            curr_key = next_key

    def items(self):

        return list(self.iteritems())

    def sort(self, cmp=None, key=None, reverse=False):

        items = [(k, v) for k, v in self.items()]

        if cmp is not None:

            items = sorted(items, cmp=cmp)

        elif key is not None:

            items = sorted(items, key=key)

        else:

            items = sorted(items, key=lambda x: x[1])

        if reverse:

            items.reverse()

        self.clear()

        self.__init__(items)

    def clear(self):

        dict_impl = self._dict_impl()

        dict_impl.clear(self)

        dict_impl.__setattr__(self, 'lh', _nil)

        dict_impl.__setattr__(self, 'lt', _nil)

    def copy(self):

        return self.__class__(self)

    def update(self, data=(), **kwds):

        if kwds:

            raise TypeError("update() of ordered dict takes no keyword "

                            "arguments to avoid an ordering trap.")

        if hasattr(data, "iteritems"):

            data = data.iteritems()

        for key, val in data:

            self[key] = val

    def setdefault(self, k, x=None):

        try:

            return self[k]

        except KeyError:

            self[k] = x

            return x

    def pop(self, k, x=_nil):

        try:

            val = self[k]

            del self[k]

            return val

        except KeyError:

            if x == _nil:

                raise

            return x

    def popitem(self):

        try:

            dict_impl = self._dict_impl()

            key = dict_impl.__getattribute__(self, 'lt')

            return key, self.pop(key)

        except KeyError:

            raise KeyError("'popitem(): ordered dictionary is empty'")

    def riterkeys(self):

        """To iterate on keys in reversed order.

        """

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lt')

        while curr_key != _nil:

            yield curr_key

            curr_key = dict_impl.__getitem__(self, curr_key)[0]

    __reversed__ = riterkeys

    def rkeys(self):

        """List of the keys in reversed order.

        """

        return list(self.riterkeys())

    def ritervalues(self):

        """To iterate on values in reversed order.

        """

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lt')

        while curr_key != _nil:

            curr_key, val, _ = dict_impl.__getitem__(self, curr_key)

            yield val

    def rvalues(self):

        """List of the values in reversed order.

        """

        return list(self.ritervalues())

    def riteritems(self):

        """To iterate on (key, value) in reversed order.

        """

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lt')

        while curr_key != _nil:

            pred_key, val, _ = dict_impl.__getitem__(self, curr_key)

            yield curr_key, val

            curr_key = pred_key

    def ritems(self):

        """List of the (key, value) in reversed order.

        """

        return list(self.riteritems())

    def firstkey(self):

        if self:

            return self._dict_impl().__getattribute__(self, 'lh')

        else:

            raise KeyError("'firstkey(): ordered dictionary is empty'")

    def lastkey(self):

        if self:

            return self._dict_impl().__getattribute__(self, 'lt')

        else:

            raise KeyError("'lastkey(): ordered dictionary is empty'")

    def as_dict(self):

        return self._dict_impl()(self.items())

    def _repr(self):

        """_repr(): low level repr of the whole data contained in the odict.

        Useful for debugging.

        """

        dict_impl = self._dict_impl()

        form = "odict low level repr lh,lt,data: %r, %r, %s"

        return form % (dict_impl.__getattribute__(self, 'lh'),

                       dict_impl.__getattribute__(self, 'lt'),

                       dict_impl.__repr__(self))

class OrderedDict(_odict, dict):

    def _dict_impl(self):

        return dict

#==============================================================================

# OrderedSet

#==============================================================================

from sqlalchemy.util import OrderedSet

from rhodecode.lib import str2bool, safe_str, get_changeset_safe,\

    generate_api_key

from rhodecode.lib.compat import json

            repo_name = value.get('fork_name')

            slug = repo_name_slug(repo_name)

            if slug in ['_admin', '']:

                e_dict = {'repo_name': _('This repository name is disallowed')}

                raise formencode.Invalid('', value, state, error_dict=e_dict)

            if RepoModel().get_by_repo_name(repo_name):

                e_dict = {'fork_name':_('This repository '

                                        'already exists')}

                raise formencode.Invalid('', value, state,

                                         error_dict=e_dict)

                if k == 'description':

                    v = v or repo_name

from rhodecode.lib import safe_unicode

                new_user.ldap_dn = safe_unicode(user_dn)

    from rhodecode.lib.compat import OrderedSet

        "webob==1.0.8"

    "https://secure.rhodecode.org/vcs/archive/default.zip#egg=vcs-0.2.2.dev",

    "https://bitbucket.org/marcinkuzminski/vcs/get/default.zip#egg=vcs-0.2.2.dev",