Changeset - 624971c4d246
Parent rev.
Child rev.
[Not reviewed]
default
0 2 0
Thomas De Schampheleire - 6 years ago 2019-06-16 20:16:44
thomas.de_schampheleire@nokia.com
Grafted from: ef6da19dbf56
setup: bump formencode minimum version to 1.3.0

The formencode version range included both 1.2.x and 1.3.x releases.
However, since 1.3.0, _to_python and validate_python are deprecated and
renamed to _convert_to_python and _validate_python, respectively.

With current pytest, these (long) deprecation warnings are shown in the test
logs.

There are two options:
- restrict maximum version to 1.2.x
- bump minimum version to 1.3.x

In this commit we choose the latter approach, going towards the future
rather than the past.
2 files changed with 34 insertions and 34 deletions:
kallithea/model/validators.py
33
33
setup.py
1
1
0 comments (0 inline, 0 general)
kallithea/model/validators.py
➞
Show inline comments
 
@@ -52,13 +52,13 @@ def UniqueListFromString():
 
        """
 
        messages = dict(
 
            empty=_('Value cannot be an empty list'),
 
            missing_value=_('Value cannot be an empty list'),
 
        )
 

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
        def _convert_to_python(self, value, state):

			




	
	
	
		
 
            value = aslist(value, ',')

			




	
	
	
		
 
            seen = set()

			




	
	
	
		
 
            return [c for c in value if not (c in seen or seen.add(c))]

			




	
	
	
		
 

			




	
	
	
		
 
        def empty_value(self, value):

			




	
	
	
		
 
            return []

			




	
	
		
 
@@ -77,13 +77,13 @@ def ValidUsername(edit=False, old_data=N

			




	
	
	
		
 
            'invalid_username':

			




	
	
	
		
 
                _('Username may only contain alphanumeric characters '

			




	
	
	
		
 
                  'underscores, periods or dashes and must begin with an '

			




	
	
	
		
 
                  'alphanumeric character or underscore')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            if value in ['default', 'new_user']:

			




	
	
	
		
 
                msg = self.message('system_invalid_username', state, username=value)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state)

			




	
	
	
		
 
            # check if user is unique

			




	
	
	
		
 
            old_un = None

			




	
	
	
		
 
            if edit:

			




	
	
		
 
@@ -109,13 +109,13 @@ def ValidRegex(msg=None):

			




	
	
	
		
 
def ValidRepoUser():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_username': _('Username %(username)s is not valid')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                User.query().filter(User.active == True) \

			




	
	
	
		
 
                    .filter(User.username == value).one()

			




	
	
	
		
 
            except sqlalchemy.exc.InvalidRequestError: # NoResultFound/MultipleResultsFound

			




	
	
	
		
 
                msg = self.message('invalid_username', state, username=value)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
		
 
@@ -135,13 +135,13 @@ def ValidUserGroup(edit=False, old_data=

			




	
	
	
		
 
            'invalid_usergroup_name':

			




	
	
	
		
 
                _('user group name may only contain alphanumeric '

			




	
	
	
		
 
                  'characters underscores, periods or dashes and must begin '

			




	
	
	
		
 
                  'with alphanumeric character')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            if value in ['default']:

			




	
	
	
		
 
                msg = self.message('invalid_group', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(users_group_name=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 
            # check if group is unique

			




	
	
		
 
@@ -176,13 +176,13 @@ def ValidRepoGroup(edit=False, old_data=

			




	
	
	
		
 
            'parent_group_id': _('Cannot assign this group as parent'),

			




	
	
	
		
 
            'group_exists': _('Group "%(group_name)s" already exists'),

			




	
	
	
		
 
            'repo_exists':

			




	
	
	
		
 
                _('Repository with name "%(group_name)s" already exists')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            # TODO WRITE VALIDATIONS

			




	
	
	
		
 
            group_name = value.get('group_name')

			




	
	
	
		
 
            parent_group_id = value.get('parent_group_id')

			




	
	
	
		
 

			




	
	
	
		
 
            # slugify repo group just in case :)

			




	
	
	
		
 
            slug = repo_name_slug(group_name)

			




	
	
		
 
@@ -232,13 +232,13 @@ def ValidPassword():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_password':

			




	
	
	
		
 
                _('Invalid characters (non-ascii) in password')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                (value or '').decode('ascii')

			




	
	
	
		
 
            except UnicodeError:

			




	
	
	
		
 
                msg = self.message('invalid_password', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,)

			




	
	
	
		
 
    return _validator

			




	
	
		
 
@@ -247,13 +247,13 @@ def ValidPassword():

			




	
	
	
		
 
def ValidOldPassword(username):

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_password': _('Invalid old password')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            from kallithea.lib import auth_modules

			




	
	
	
		
 
            if auth_modules.authenticate(username, value, '') is None:

			




	
	
	
		
 
                msg = self.message('invalid_password', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(current_password=msg)

			




	
	
	
		
 
                )

			




	
	
		
 
@@ -263,13 +263,13 @@ def ValidOldPassword(username):

			




	
	
	
		
 
def ValidPasswordsMatch(password_field, password_confirmation_field):

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'password_mismatch': _('Passwords do not match'),

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            if value.get(password_field) != value[password_confirmation_field]:

			




	
	
	
		
 
                msg = self.message('password_mismatch', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                     error_dict={password_field:msg, password_confirmation_field: msg}

			




	
	
	
		
 
                )

			




	
	
	
		
 
    return _validator

			




	
	
		
 
@@ -278,13 +278,13 @@ def ValidPasswordsMatch(password_field, 

			




	
	
	
		
 
def ValidAuth():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_auth': _(u'Invalid username or password'),

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            from kallithea.lib import auth_modules

			




	
	
	
		
 

			




	
	
	
		
 
            password = value['password']

			




	
	
	
		
 
            username = value['username']

			




	
	
	
		
 

			




	
	
	
		
 
            # authenticate returns unused dict but has called

			




	
	
		
 
@@ -309,13 +309,13 @@ def ValidAuth():

			




	
	
	
		
 
def ValidAuthToken():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_token': _('Token mismatch')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            if value != authentication_token():

			




	
	
	
		
 
                msg = self.message('invalid_token', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state)

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
		
 
@@ -331,13 +331,13 @@ def ValidRepoName(edit=False, old_data=N

			




	
	
	
		
 
            'repository_in_group_exists': _('Repository "%(repo)s" already '

			




	
	
	
		
 
                                            'exists in group "%(group)s"'),

			




	
	
	
		
 
            'same_group_exists': _('Repository group with name "%(repo)s" '

			




	
	
	
		
 
                                   'already exists')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
        def _convert_to_python(self, value, state):

			




	
	
	
		
 
            repo_name = repo_name_slug(value.get('repo_name', ''))

			




	
	
	
		
 
            repo_group = value.get('repo_group')

			




	
	
	
		
 
            if repo_group:

			




	
	
	
		
 
                gr = RepoGroup.get(repo_group)

			




	
	
	
		
 
                group_path = gr.full_path

			




	
	
	
		
 
                group_name = gr.group_name

			




	
	
		
 
@@ -352,13 +352,13 @@ def ValidRepoName(edit=False, old_data=N

			




	
	
	
		
 
            value['repo_name'] = repo_name

			




	
	
	
		
 
            value['repo_name_full'] = repo_name_full

			




	
	
	
		
 
            value['group_path'] = group_path

			




	
	
	
		
 
            value['group_name'] = group_name

			




	
	
	
		
 
            return value

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            repo_name = value.get('repo_name')

			




	
	
	
		
 
            repo_name_full = value.get('repo_name_full')

			




	
	
	
		
 
            group_path = value.get('group_path')

			




	
	
	
		
 
            group_name = value.get('group_name')

			




	
	
	
		
 

			




	
	
	
		
 
            if repo_name in [ADMIN_PREFIX, '']:

			




	
	
		
 
@@ -399,16 +399,16 @@ def ValidForkName(*args, **kwargs):

			




	
	
	
		
 
    return ValidRepoName(*args, **kwargs)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def SlugifyName():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
        def _convert_to_python(self, value, state):

			




	
	
	
		
 
            return repo_name_slug(value)

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            pass

			




	
	
	
		
 

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidCloneUri():

			




	
	
		
 
@@ -418,13 +418,13 @@ def ValidCloneUri():

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'clone_uri': _('Invalid repository URL'),

			




	
	
	
		
 
            'invalid_clone_uri': _('Invalid repository URL. It must be a '

			




	
	
	
		
 
                                   'valid http, https, ssh, svn+http or svn+https URL'),

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            repo_type = value.get('repo_type')

			




	
	
	
		
 
            url = value.get('clone_uri')

			




	
	
	
		
 

			




	
	
	
		
 
            if url and url != value.get('clone_uri_hidden'):

			




	
	
	
		
 
                try:

			




	
	
	
		
 
                    is_valid_repo_uri(repo_type, url, make_ui(clear_session=False))

			




	
	
		
 
@@ -442,13 +442,13 @@ def ValidForkType(old_data=None):

			




	
	
	
		
 

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_fork_type': _('Fork has to be the same type as parent')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            if old_data['repo_type'] != value:

			




	
	
	
		
 
                msg = self.message('invalid_fork_type', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(repo_type=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 
    return _validator

			




	
	
		
 
@@ -460,19 +460,19 @@ def CanWriteGroup(old_data=None):

			




	
	
	
		
 
            'permission_denied': _("You don't have permissions "

			




	
	
	
		
 
                                   "to create repository in this group"),

			




	
	
	
		
 
            'permission_denied_root': _("no permission to create repository "

			




	
	
	
		
 
                                        "in root location")

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
        def _convert_to_python(self, value, state):

			




	
	
	
		
 
            # root location

			




	
	
	
		
 
            if value == -1:

			




	
	
	
		
 
                return None

			




	
	
	
		
 
            return value

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            gr = RepoGroup.get(value)

			




	
	
	
		
 
            gr_name = gr.group_name if gr is not None else None # None means ROOT location

			




	
	
	
		
 

			




	
	
	
		
 
            # create repositories with write permission on group is set to true

			




	
	
	
		
 
            create_on_write = HasPermissionAny('hg.create.write_on_repogroup.true')()

			




	
	
	
		
 
            group_admin = HasRepoGroupPermissionLevel('admin')(gr_name,

			




	
	
		
 
@@ -516,13 +516,13 @@ def CanCreateGroup(can_create_in_root=Fa

			




	
	
	
		
 
        def to_python(self, value, state):

			




	
	
	
		
 
            # root location

			




	
	
	
		
 
            if value == -1:

			




	
	
	
		
 
                return None

			




	
	
	
		
 
            return value

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            gr = RepoGroup.get(value)

			




	
	
	
		
 
            gr_name = gr.group_name if gr is not None else None # None means ROOT location

			




	
	
	
		
 

			




	
	
	
		
 
            if can_create_in_root and gr is None:

			




	
	
	
		
 
                # we can create in root, we're fine no validations required

			




	
	
	
		
 
                return

			




	
	
		
 
@@ -616,13 +616,13 @@ def ValidPerms(type_='repo'):

			




	
	
	
		
 
            return value

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidSettings():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
        def _convert_to_python(self, value, state):

			




	
	
	
		
 
            # settings  form for users that are not admin

			




	
	
	
		
 
            # can't edit certain parameters, it's extra backup if they mangle

			




	
	
	
		
 
            # with forms

			




	
	
	
		
 

			




	
	
	
		
 
            forbidden_params = [

			




	
	
	
		
 
                'user', 'repo_type',

			




	
	
		
 
@@ -631,24 +631,24 @@ def ValidSettings():

			




	
	
	
		
 

			




	
	
	
		
 
            for param in forbidden_params:

			




	
	
	
		
 
                if param in value:

			




	
	
	
		
 
                    del value[param]

			




	
	
	
		
 
            return value

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            pass

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidPath():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_path': _('This is not a valid path')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            if not os.path.isdir(value):

			




	
	
	
		
 
                msg = self.message('invalid_path', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(paths_root_path=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 
    return _validator

			




	
	
		
 
@@ -659,16 +659,16 @@ def UniqSystemEmail(old_data=None):

			




	
	
	
		
 

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'email_taken': _('This email address is already in use')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
        def _convert_to_python(self, value, state):

			




	
	
	
		
 
            return value.lower()

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            if (old_data.get('email') or '').lower() != value:

			




	
	
	
		
 
                user = User.get_by_email(value)

			




	
	
	
		
 
                if user is not None:

			




	
	
	
		
 
                    msg = self.message('email_taken', state)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                        error_dict=dict(email=msg)

			




	
	
		
 
@@ -679,16 +679,16 @@ def UniqSystemEmail(old_data=None):

			




	
	
	
		
 
def ValidSystemEmail():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'non_existing_email': _('Email address "%(email)s" not found')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
        def _convert_to_python(self, value, state):

			




	
	
	
		
 
            return value.lower()

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            user = User.get_by_email(value)

			




	
	
	
		
 
            if user is None:

			




	
	
	
		
 
                msg = self.message('non_existing_email', state, email=value)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(email=msg)

			




	
	
	
		
 
                )

			




	
	
		
 
@@ -699,13 +699,13 @@ def ValidSystemEmail():

			




	
	
	
		
 
def LdapLibValidator():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                import ldap

			




	
	
	
		
 
                ldap  # pyflakes silence !

			




	
	
	
		
 
            except ImportError:

			




	
	
	
		
 
                raise LdapImportError()

			




	
	
	
		
 

			




	
	
		
 
@@ -744,13 +744,13 @@ def ValidIp():

			




	
	
	
		
 
            if isinstance(net, ipaddr.IPv6Network):

			




	
	
	
		
 
                # if IPv6 doesn't end with a mask, add /128

			




	
	
	
		
 
                if '/' not in value:

			




	
	
	
		
 
                    v += '/128'

			




	
	
	
		
 
            return v

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                addr = value.strip()

			




	
	
	
		
 
                # this raises an ValueError if address is not IPv4 or IPv6

			




	
	
	
		
 
                ipaddr.IPNetwork(address=addr)

			




	
	
	
		
 
            except ValueError:

			




	
	
	
		
 
                raise formencode.Invalid(self.message('badFormat', state),

			




	
	
		
 
@@ -763,46 +763,46 @@ def FieldKey():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = dict(

			




	
	
	
		
 
            badFormat=_('Key name can only consist of letters, '

			




	
	
	
		
 
                        'underscore, dash or numbers')

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            if not re.match('[a-zA-Z0-9_-]+$', value):

			




	
	
	
		
 
                raise formencode.Invalid(self.message('badFormat', state),

			




	
	
	
		
 
                                         value, state)

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def BasePath():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = dict(

			




	
	
	
		
 
            badPath=_('Filename cannot be inside a directory')

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
        def _convert_to_python(self, value, state):

			




	
	
	
		
 
            return value

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            if value != os.path.basename(value):

			




	
	
	
		
 
                raise formencode.Invalid(self.message('badPath', state),

			




	
	
	
		
 
                                         value, state)

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidAuthPlugins():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = dict(

			




	
	
	
		
 
            import_duplicate=_('Plugins %(loaded)s and %(next_to_load)s both export the same name')

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
        def _convert_to_python(self, value, state):

			




	
	
	
		
 
            # filter empty values

			




	
	
	
		
 
            return filter(lambda s: s not in [None, ''], value)

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
        def _validate_python(self, value, state):

			




	
	
	
		
 
            from kallithea.lib import auth_modules

			




	
	
	
		
 
            module_list = value

			




	
	
	
		
 
            unique_names = {}

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                for module in module_list:

			




	
	
	
		
 
                    plugin = auth_modules.loadplugin(module)

			




        

    


    
    

    

        

                

                    setup.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -41,13 +41,13 @@ requirements = [

			




	
	
	
		
 
    "WebOb >= 1.7, < 1.8", # turbogears2 2.3.12 requires WebOb<1.8.0

			




	
	
	
		
 
    "backlash >= 0.1.2, < 1",

			




	
	
	
		
 
    "TurboGears2 >= 2.3.10, < 2.4", # TODO: 2.4 drops Pylons compatibility

			




	
	
	
		
 
    "tgext.routes >= 0.2.0, < 1",

			




	
	
	
		
 
    "Beaker >= 1.7.0, < 2",

			




	
	
	
		
 
    "WebHelpers >= 1.3, < 1.4",

			




	
	
	
		
 
    "FormEncode >= 1.2.4, < 1.4",

			




	
	
	
		
 
    "FormEncode >= 1.3.0, < 1.4",

			




	
	
	
		
 
    "SQLAlchemy >= 1.1, < 1.4",

			




	
	
	
		
 
    "Mako >= 0.9.0, < 1.1",

			




	
	
	
		
 
    "Pygments >= 2.0, < 2.5",

			




	
	
	
		
 
    "Whoosh >= 2.5.0, < 2.8",

			




	
	
	
		
 
    "celery >= 3.1, < 4.0", # TODO: celery 4 doesn't work

			




	
	
	
		
 
    "Babel >= 1.3, < 2.8",

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.