This file is indexed.

/usr/lib/python2.7/dist-packages/elixir/collection.py is in python-elixir 0.7.1-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
'''
Default entity collection implementation
'''
import sys
import re

from elixir.py23compat import rsplit

class BaseCollection(list):
    def __init__(self, entities=None):
        list.__init__(self)
        if entities is not None:
            self.extend(entities)

    def extend(self, entities):
        for e in entities:
            self.append(e)

    def clear(self):
        del self[:]

    def resolve_absolute(self, key, full_path, entity=None, root=None):
        if root is None:
            root = entity._descriptor.resolve_root
        if root:
            full_path = '%s.%s' % (root, full_path)
        module_path, classname = rsplit(full_path, '.', 1)
        module = sys.modules[module_path]
        res = getattr(module, classname, None)
        if res is None:
            if entity is not None:
                raise Exception("Couldn't resolve target '%s' <%s> in '%s'!"
                                % (key, full_path, entity.__name__))
            else:
                raise Exception("Couldn't resolve target '%s' <%s>!"
                                % (key, full_path))
        return res

    def __getattr__(self, key):
        return self.resolve(key)

# default entity collection
class GlobalEntityCollection(BaseCollection):
    def __init__(self, entities=None):
        # _entities is a dict of entities keyed on their name.
        self._entities = {}
        super(GlobalEntityCollection, self).__init__(entities)

    def append(self, entity):
        '''
        Add an entity to the collection.
        '''
        super(EntityCollection, self).append(entity)

        existing_entities = self._entities.setdefault(entity.__name__, [])
        existing_entities.append(entity)

    def resolve(self, key, entity=None):
        '''
        Resolve a key to an Entity. The optional `entity` argument is the
        "source" entity when resolving relationship targets.
        '''
        # Do we have a fully qualified entity name?
        if '.' in key:
            return self.resolve_absolute(key, key, entity)
        else:
            # Otherwise we look in the entities of this collection
            res = self._entities.get(key, None)
            if res is None:
                if entity:
                    raise Exception("Couldn't resolve target '%s' in '%s'"
                                    % (key, entity.__name__))
                else:
                    raise Exception("This collection does not contain any "
                                    "entity corresponding to the key '%s'!"
                                    % key)
            elif len(res) > 1:
                raise Exception("'%s' resolves to several entities, you should"
                                " use the full path (including the full module"
                                " name) to that entity." % key)
            else:
                return res[0]

    def clear(self):
        self._entities = {}
        super(GlobalEntityCollection, self).clear()

# backward compatible name
EntityCollection = GlobalEntityCollection

_leading_dots = re.compile('^([.]*).*$')

class RelativeEntityCollection(BaseCollection):
    # the entity=None does not make any sense with a relative entity collection
    def resolve(self, key, entity):
        '''
        Resolve a key to an Entity. The optional `entity` argument is the
        "source" entity when resolving relationship targets.
        '''
        full_path = key

        if '.' not in key or key.startswith('.'):
            # relative target

            # any leading dot is stripped and with each dot removed,
            # the entity_module is stripped of one more chunk (starting with
            # the last one).
            num_dots = _leading_dots.match(full_path).end(1)
            full_path = full_path[num_dots:]
            chunks = entity.__module__.split('.')
            chunkstokeep = len(chunks) - num_dots
            if chunkstokeep < 0:
                raise Exception("Couldn't resolve relative target "
                    "'%s' relative to '%s'" % (key, entity.__module__))
            entity_module = '.'.join(chunks[:chunkstokeep])

            if entity_module and entity_module is not '__main__':
                full_path = '%s.%s' % (entity_module, full_path)

            root = ''
        else:
            root = None
        return self.resolve_absolute(key, full_path, entity, root=root)

    def __getattr__(self, key):
        raise NotImplementedError