'Given the path to a given field, return a list containing
the Field object associated with that field and all of its parent
Field objects.
Args:
parts (str, list, or tuple) - path to the field. Should be a
string for simple fields existing on this document or a list
of strings for a field that exists deeper in embedded documents.
Returns:
A list of Field instances for fields that were found or
strings for sub-fields that weren\'t.
Example:
>>> user._lookup_field(\'name\')
[<mongoengine.fields.StringField at 0x1119bff50>]
>>> user._lookup_field(\'roles\')
[<mongoengine.fields.EmbeddedDocumentListField at 0x1119ec250>]
>>> user._lookup_field([\'roles\', \'role\'])
[<mongoengine.fields.EmbeddedDocumentListField at 0x1119ec250>,
<mongoengine.fields.StringField at 0x1119ec050>]
>>> user._lookup_field(\'doesnt_exist\')
raises LookUpError
>>> user._lookup_field([\'roles\', \'doesnt_exist\'])
[<mongoengine.fields.EmbeddedDocumentListField at 0x1119ec250>,
\'doesnt_exist\']'

@classmethod
def _lookup_field(cls, parts):

    ListField = _import_class('ListField')
    DynamicField = _import_class('DynamicField')
    if (not isinstance(parts, (list, tuple))):
        parts = [parts]
    fields = []
    field = None
    for field_name in parts:
        if (field_name.isdigit() and isinstance(field, ListField)):
            fields.append(field_name)
            continue
        if (field is None):
            if (field_name == 'pk'):
                field_name = cls._meta['id_field']
            if (field_name in cls._fields):
                field = cls._fields[field_name]
            elif cls._dynamic:
                field = DynamicField(db_field=field_name)
            elif (cls._meta.get('allow_inheritance') or cls._meta.get('abstract', False)):
                for subcls in cls.__subclasses__():
                    try:
                        field = subcls._lookup_field([field_name])[0]
                    except LookUpError:
                        continue
                    if (field is not None):
                        break
                else:
                    raise LookUpError(('Cannot    resolve    field    "%s"' % field_name))
            else:
                raise LookUpError(('Cannot    resolve    field    "%s"' % field_name))
        else:
            ReferenceField = _import_class('ReferenceField')
            GenericReferenceField = _import_class('GenericReferenceField')
            if isinstance(field, (ReferenceField, GenericReferenceField)):
                raise LookUpError(('Cannot    perform    join    in    mongoDB:    %s' % '__'.join(parts)))
            if hasattr(getattr(field, 'field', None), 'lookup_member'):
                new_field = field.field.lookup_member(field_name)
            elif (cls._dynamic and (isinstance(field, DynamicField) or getattr(getattr(field, 'document_type', None), '_dynamic', None))):
                new_field = DynamicField(db_field=field_name)
            elif hasattr(field, 'lookup_member'):
                new_field = field.lookup_member(field_name)
            else:
                raise LookUpError('Cannot    resolve    subfield    or    operator    {}    on    the    field    {}'.format(field_name, field.name))
            if ((not new_field) and isinstance(field, ComplexBaseField)):
                fields.append(field_name)
                continue
            elif (not new_field):
                raise LookUpError(('Cannot    resolve    field    "%s"' % field_name))
            field = new_field
        fields.append(field)
    return fields
