This file is indexed.

/usr/share/pyshared/dap/plugins/csvfiles.py is in python-dap 2.2.6.7-1.

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
"""Plugin for CSV (comma separated values) files.

This plugin serves sequential data from a CSV file. It's a bit hackish and
abuses ``lambda`` and ``itertools``, but it works *very* nice. The plugin
uses the ``buildfilter()`` function to create a filter from the constraint
expression, and applies it on-the-fly on the data as it is being read.
"""

__author__ = "Roberto De Almeida <rob@pydap.org>"

import sys
import os.path
import re
import csv
import itertools
import urllib

from dap import dtypes
from dap.responses.das import typeconvert
from dap.server import BaseHandler
from dap.exceptions import OpenFileError
from dap.helper import buildfilter, parse_querystring
from dap.util.safeeval import expr_eval

extensions = r"""^.*\.(csv|CSV)$"""


def lazy_eval(s):
    """Try to evalute expression or fallback to string.
    
        >>> lazy_eval("1")
        1
        >>> lazy_eval("None")
        'None'
    """
    try:
        s = expr_eval(s)
    except:
        pass
    return s
    

class Handler(BaseHandler):
    def __init__(self, filepath, environ):
        """Handler constructor.
        """
        self.filepath = filepath
        self.environ = environ
        dir, self.filename = os.path.split(filepath)

        # Add dummy description.
        self.description = "Comma Separated Values from file %s." % self.filename

    def _parseconstraints(self, constraints=None):
        """Dataset builder.

        This method opens a CSV reader, extracts the variable names from
        the first line and returns an iterator to the data. Constraint
        expressions or handled by the ``get_filter()`` function and a 
        filter to return only data from the columns corresponding to the
        requested variables.
        """
        try:
            self._file = open(self.filepath)
            reader = csv.reader(self._file)
        except:
            message = 'Unable to open file %s.' % self.filepath
            raise OpenFileError(message)

        # Parse constraints.
        fields, queries = parse_querystring(constraints)

        # Build the dataset.
        dataset = dtypes.DatasetType(name=self.filename)
        dataset.attributes['filename'] = self.filename

        # Create sequence.
        name = self.filename[:-4].split('_', 1)[0]
        seq = dataset[name] = dtypes.SequenceType(name=name)

        # Read variables names.
        fieldnames = reader.next()
        ids = ['%s.%s' % (seq.name, n) for n in fieldnames]

        # We need to read the first line to grab the fields names and peek types.
        line = reader.next()
        types_ = [lazy_eval(i) for i in line]
        types_ = [typeconvert[type(i)] for i in types_]
        
        # Get list of requested variables.
        if seq.id in fields.keys():
            req_ids = []  # put everything
        else:
            # Check for shorthand notation. Ugly, ugly hack. If the requested
            # var is not in the list of ids we append the sequence id to it,
            # assuming that is was requested using the shorthand notation syntax.
            req_ids = [['%s.%s' % (seq.id, var), var][var in ids] for var in fields.keys()]

        # Add requested variables.
        if req_ids:
            indexes = []
            for id_ in req_ids:
                if id_ in ids:
                    i = ids.index(id_)
                    indexes.append(i)
                    name = fieldnames[i]
                    type_ = types_[i]
                    seq[name] = dtypes.BaseType(name=name, type=type_)
        else:
            for name, type_ in zip(fieldnames, types_):
                seq[name] = dtypes.BaseType(name=name, type=type_)

        # Reinsert first data line.
        data = itertools.chain([line], reader)
        data = itertools.imap(lambda l: map(lazy_eval, l), data)

        # Filter results.
        if queries:
            # Get filter.
            filter1 = buildfilter(queries, ids)
            data = itertools.ifilter(filter1, data)

        # Select only requested variables.
        if req_ids:
            filter2 = lambda x: [x[i] for i in indexes]
            data = itertools.imap(filter2, data)

        # Apply stride to sequence?
        slice_ = fields.get(seq.id)
        if slice_:
            slice_ = slice_[0]
            data = itertools.islice(data, slice_.start or 0, slice_.stop or sys.maxint, slice_.step or 1)
        else:
            # Check stored variables. If more than one variable is selected,
            # and they have different slices, use the most restritive start,
            # step and stop.
            #
            # Behaviour rev-eng'ed from http://test.opendap.org/dap/data/ff/1998-6-avhrr.dat
            slices = []
            for var in seq.walk():
                slice_ = fields.get(var.id)
                if slice_: slices.append(slice_[0])
            if slices:
                start, step, stop = zip(*[(s.start or 0, s.step or 1, s.stop or sys.maxint) for s in slices])
                data = itertools.islice(data, max(start), min(stop), max(step))

        # Insert data directly into sequence.
        seq.data = data

        return dataset

    def close(self):
        """Close the CSV file."""
        if hasattr(self, '_file'): self._file.close()


def _test():
    import doctest
    doctest.testmod()

if __name__ == "__main__":
    _test()