LIST_PARAMS = """CELERY_IMPORTS ADMINS ROUTES CELERY_ACCEPT_CONTENT""".split()

    for config_key, config_value in sorted(config.items()):

        celery_key = config_key.replace('.', '_').upper()

        if celery_key.split('_', 1)[0] not in PREFIXES:

            continue

            continue

        if celery_key in LIST_PARAMS:

            celery_value = config_value.split()

        elif config_value.isdigit():

            celery_value = int(config_value)

        elif config_value.lower() in ['true', 'false']:

        option_list = options

        # Handle old value,label lists ... where value also can be value,label lists

        options = Options()

        for x in option_list:

            if isinstance(x, tuple) and len(x) == 2:

                value, label = x

                value = label = x

            else:

                log.error('invalid select option %r', x)

                raise

            if isinstance(value, list):

                og = options.add_optgroup(label)

                for x in value:

                    if isinstance(x, tuple) and len(x) == 2:

                        group_value, group_label = x

                        group_value = group_label = x

                    else:

                        log.error('invalid select option %r', x)

                        raise

                    og.add_option(group_label, group_value)

            else:

        self.content_type = content_type

        self.disposition = disposition or 'attachment'

        self._data = data

    @property

    def data(self):

            return self._data

        self._data = self._data.read()

        return self._data

class Message(object):

        self.debug = debug

        self.auth = smtp_auth

    def send(self, recipients=None, subject='', body='', html='',

             attachment_files=None, headers=None):

        recipients = recipients or []

            recipients = [recipients]

        if headers is None:

            headers = {}

        headers.setdefault('Date', formatdate(time.time()))

        msg = Message(subject, recipients, body, html, self.mail_from,

                      recipients_separator=", ", extra_headers=headers)

    # in tmpl context var

    if not ipaddr:

        ipaddr = getattr(get_current_authuser(), 'ip_addr', '')

    if getattr(user, 'user_id', None):

        user_obj = User.get(user.user_id)

        user_obj = User.get_by_username(user)

    else:

        raise Exception('You have to provide a user object or a username')

    if getattr(repo, 'repo_id', None):

        repo_obj = Repository.get(repo.repo_id)

        repo_name = repo_obj.repo_name

        repo_name = repo.lstrip('/')

        repo_obj = Repository.get_by_repo_name(repo_name)

    else:

        repo_obj = None

        repo_name = u''

    Returns given string separated by sep as list

    :param obj:

    :param sep:

    :param strip:

    """

        lst = obj.split(sep)

        if strip:

            lst = [v.strip() for v in lst]

        return lst

    elif isinstance(obj, (list, tuple)):

        return obj

    if dt:

        return time.mktime(dt.timetuple())

def time_to_datetime(tm):

    if tm:

            try:

                tm = float(tm)

            except ValueError:

                return

        return datetime.datetime.fromtimestamp(tm)

        :param name: Name of configuration we want to retrieve

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        if config_file is None:

            config_file = []

            config_file = [config_file]

        def gen_configs():

            for path in config_file + self._config_files:

                try:

                    yield ConfigFile.from_path(path)

    """

    Represents state of the repository at a revision.

    """

    def __init__(self, repository, revision):

        self.repository = repository

        self._ctx = repository._repo[ascii_bytes(revision)]

        self.raw_id = ascii_str(self._ctx.hex())

        self.revision = self._ctx._rev

        self.nodes = {}

    @LazyProperty

        :param name: Name of configuration we want to retrieve

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        if config_file is None:

            config_file = []

            config_file = [config_file]

        config = self._repo.ui

        if config_file:

            config = mercurial.ui.ui()

            for path in config_file:

    Returns given string separated by sep as list

    :param obj:

    :param sep:

    :param strip:

    """

        lst = obj.split(sep)

        if strip:

            lst = [v.strip() for v in lst]

        return lst

    elif isinstance(obj, (list, tuple)):

        return obj

        if value is None:

            return None

        if isinstance(value, cls):

            return value

        if isinstance(value, int):

            return cls.get(value)

            return cls.get(int(value))

        if callback is not None:

            return callback(value)

        raise Exception(

            'given object must be int, long or Instance of %s '

    def __get_repo(self, instance):

        cls = Repository

        if isinstance(instance, cls):

            return instance

        elif isinstance(instance, int):

            return cls.get(instance)

            if instance.isdigit():

                return cls.get(int(instance))

            return cls.get_by_repo_name(instance)

        elif instance is not None:

            raise Exception('given object must be int, basestr or Instance'

                            ' of %s got %s' % (type(cls), type(instance)))

        for f_path in nodes:

            content = nodes[f_path]['content']

            f_path = self._sanitize_path(f_path)

            f_path = safe_str(f_path)

            # decoding here will force that we have proper encoded values

            # in any other case this will throw exceptions and deny commit

                content = safe_str(content)

            else:

                content = content.read()

            processed_nodes.append((f_path, content))

        message = safe_unicode(message)

            user_group = UserGroup.guess_instance(user_group)

            for k, v in form_data.items():

                if k == 'users_group_members':

                    members_list = []

                    if v:

                        for u_id in set(v):

                            member = UserGroupMember(user_group.users_group_id, u_id)

                            members_list.append(member)

                            Session().add(member)

                    user_group.members = members_list

                setattr(user_group, k, v)

]

urllib2.install_opener(o)

def _get_repo(proj):

        repo = vcs.get_repo(os.path.join(PROJECT_PATH, proj))

        proj = proj

    else:

        repo = proj

        proj = repo.name