Synnefo

from collections import defaultdict

    def access_get_for_bulk(self, perms):

        """Get permissions for paths."""

        allowed = None

        d = defaultdict(list)

        for value, feature_id, key in perms:

            d[key].append(value)

        permissions = d

        if READ in permissions:

            allowed = 0

            permissions['read'] = permissions[READ]

            del(permissions[READ])

        if WRITE in permissions:

            allowed = 1

            permissions['write'] = permissions[WRITE]

            del(permissions[WRITE])

        return (permissions, allowed)

    def access_check_bulk(self, paths, member):

        rows = None

        q = ("select x.path, xvals.value, xvals.feature_id, xvals.key "

             "from xfeaturevals xvals join xfeatures x "

             "on xvals.feature_id = x.feature_id "

             "where x.path in (%s)") % ','.join('?' for _ in paths)

        self.execute(q, paths)

        rows = self.fetchall()

        if rows:

            access_check_paths = {}

            for path, value, feature_id, key in rows:

                try:

                    access_check_paths[path].append((value, feature_id, key))

                except KeyError:

                    access_check_paths[path] = [(value, feature_id, key)]

            return access_check_paths

        return None

    def access_inherit_bulk(self, paths):

        """Return the paths influencing the access for paths."""

        # Only keep path components.

        valid = []

        for path in paths:

            parts = path.rstrip('/').split('/')

            for i in range(1, len(parts)):

                subp = '/'.join(parts[:i + 1])

                valid.append(subp)

                if subp != path:

                    valid.append(subp + '/')

        valid = self.xfeature_get_bulk(valid)

        return [x[1] for x in valid]

            q += " where "

            paths = self.access_inherit(prefix) or [prefix]

            q += ' or '.join("path like ? escape '\\'" for _ in paths)

            p += tuple(self.escape_like(path) + '%' for path in paths)

        q = "select path from xfeatures where "

        paths = self.access_inherit(prefix) or [prefix]

        q += ' or '.join("path like ? escape '\\'" for _ in paths)

        p = tuple(self.escape_like(path) + '%' for path in paths)