Group element in list based on conditions and indexes

I have a set of lists composed of names and role. However, there is no real logic between how the list are organized.

For instance, I have this list :

l = ['john', 'owner', 'mark', 'manager', 'alex', 'steve', 'employee', 'manager'] #the last role shouldn't be assigned to anyone 

I want to assign each person the role that is located next to it in the list or the closest one from left to right.

The desired output should be something like :

output = [['john', 'owner'], ['mark', 'manager'], ['alex', 'employee'], ['steve', 'employee']]  

My guess was to add indexes to the list elements, and than check which element based on a set of condition was closest to the list element I was looking at.

This is part of my script :

parties_role = [(idx, item) for idx,item in enumerate(l)]
    for item in parties_role:
        if "owner" not in str(item[1]) and 'manager' not in str(item[1]) and 'employee' not in str(item[1]):
        name = str(item[1])

The rest of the code shoud look at the list items that contain the keywords owner, manager and employee and assign to the current name variable the closest role based on the index.

Let's create a set of "roles":

roles = {'owner', 'manager', 'employee'}

Now, let's use reduce. Our accumulator is a tuple with two lists: the final result and the second list is a "bucket" of names read thus far. When it encounters a role, it maps those names to that role and adds them to the result list.

>>> from functools import reduce
>>> grouped = reduce(
...   lambda acc, x: 
...     (acc[0] + [[y, x] for y in acc[1]], []) if x in roles else 
...     (acc[0], acc[1] + [x]), 
...   l, 
...   ([], [])
... )
>>> grouped[0]
[['john', 'owner'], ['mark', 'manager'], ['alex', 'employee'], ['steve', 'employee']]

You could start with a set of known roles...you need some way to tell names from roles, so I assume this is possible. With that you can group by whether the string is a name or a role. This should give you alternating groups of names and roles. Then zip and assemble:

from itertools import groupby

roles = {'owner', 'manager', 'employee'}    
l = ['john', 'owner', 'mark', 'manager', 'alex', 'steve', 'employee', 'manager']

groups = (list(v) for _, v in groupby(l, key=lambda s: s in roles))
result = [[name, roles[0]] for names, roles in zip(groups, groups) for name in names]

This produces a result of:

[['john', 'owner'],
 ['mark', 'manager'],
 ['alex', 'employee'],
 ['steve', 'employee']]

It makes the assumption that the original list starts with a name.

I might do it like this:

• Define which strings are roles and which aren't (e.g. create a set of valid roles, assume everything else is a name).
• Iterate over each name in l, using enumerate to track the index.
  • For each name, find the next element in l (after the name's index) that's a role.

>>> l = ['john', 'owner', 'mark', 'manager', 'alex', 'steve', 'employee', 'manager']
>>> roles = {'owner', 'manager', 'employee'}
>>> [[name, next(e for e in l[i:] if e in roles)] for i, name in enumerate(l) if name not in roles]
[['john', 'owner'], ['mark', 'manager'], ['alex', 'employee'], ['steve', 'employee']]