Produits Entr'ouvert » Authentic 2

            config_error(MISSING_KEYS_ERROR, missing)

        dependencies = d['dependencies']

        if not isinstance(dependencies, (list, tuple)) or \

            config_error(DEPENDENCY_TYPE_ERROR)

        if not callable(d['function']):

    from ldap.dn import escape_dn_chars

    from ldap.ldapobject import ReconnectLDAPObject as NativeLDAPObject

    from ldap.controls import SimplePagedResultsControl

    LDAPObject = NativeLDAPObject

except ImportError:

    ldap = None

                if mod_vals is None:

                    pass

                elif isinstance(mod_vals, list):

                else:

                    mod_vals = convert(mod_vals)

                new_modlist.append((mod_op, mod_typ, mod_vals))

            base = force_bytes(base)

            filterstr = force_bytes(filterstr)

            if attrlist:

            return NativeLDAPObject.search_ext(self, base, scope,

                                               filterstr=filterstr,

                                               attrlist=attrlist,

                if mod_vals is None:

                    pass

                elif isinstance(mod_vals, list):

                else:

                    mod_vals = convert(mod_vals)

                new_modlist.append((mod_op, mod_typ, mod_vals))

        new_attributes = {}

        for key in attributes:

            try:

            except UnicodeDecodeError:

                log.debug('unable to decode attribute %r as UTF-8, converting to base64', key)

        return new_attributes

    @classmethod

                return atv.to_python()

            else:

                # multiple

        return None

        self.key_prefix = key_prefix

    def key(self, keys):

        key = key.encode('utf-8')

        return '%s%s' % (self.key_prefix or self.KEY_PREFIX, hashlib.md5(key).hexdigest())

        logout.request.sessionIndexes = []

    else:

        session_indexes = lib_sessions.values_list('session_index', flat=True)

    logout.msgRelayState = logout.request.id

    try:

        logout.buildRequestMsg()

        raise NotImplementedError

    def render(self, value, object):

class UserResource(ModelResource):

            result.add(role)

            for pr in role.parent_relation.all():

                result.add(pr.parent)

    class Meta:

        model = User

            for attr in attributes:

                record.append(attr_d.get(attr))

        self._dataset = tablib.Dataset(headers=headers)

        for user in self.get_data():

                'members', queryset=User.objects.filter(pk=self.object.pk),

                to_attr='member'))

            qs2 = self.request.user.filter_by_perm('a2_rbac.manage_members_role', qs)

            qs = qs.extra(select={'has_perm': 'a2_rbac_role.id in (%s)' % ', '.join(managable_ids)})

            qs = qs.exclude(slug__startswith='_a2-managers-of-role')

            return qs

def prepend_remember_cookie(request, response, name, value, count=5):

    values = get_remember_cookie(request, name, count=count)

    values = [value] + values[:count - 1]

                        max_age=86400 * 365,  # keep preferences for 1 year

                        path=request.path,

                        httponly=True)

                if not isinstance(value, (list, tuple)):

                    value = (value,)

                raw_value = value

            if value or app_settings.A2_PROFILE_DISPLAY_EMPTY_FIELDS:

                profile.append((title, value))

                attributes.append({'attribute': attribute, 'values': raw_value})

                raise CommandError('invalid claim mapping %r. it must contain at least a claim and '

                                   'an attribute name')

            claim, attribute = tup[:2]

            extra = {

                'required': 'required' in claim_options,

                'idtoken_claim': 'idtoken' in claim_options,

def clean_words(data):

    '''Clean and order a list of words'''

def url_domain(url):

def test_openldap_hashers():

coin {SHA}NHj+acfc68FPYrMipEBZ3t8ABGY=

250523 {SHA}4zuJhPW1w0upqG7beAlxDcvtBj0=

coin {SSHA}zLPxfZ3RSNkIwVdHWEyB4Tpr6fT9LiVX

coin {SMD5}+x9QkU2T/wlPp6NK3bfYYxPYwaE=

    for password, oldap_hash in VECTORS:

        dj_hash = hashers.olap_password_to_dj(oldap_hash)

        assert check_password(password, dj_hash)