← Back to branch summary

~ubuntu-branches/debian/stretch/electrum/stretch

« back to all changes in this revision

Viewing changes to gui/kivy/tools/.buildozer/android/platform/python-for-android/dist/kivy/python-install/lib/python2.7/fileinput.py

  • Committer: Package Import Robot
  • Author(s): Tristan Seligmann
  • Date: 2016-04-04 03:02:39 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20160404030239-0szgkio8yryjv7c9
Tags: 2.6.3-1
http://bugs.debian.org/819517
* New upstream release.
  - Drop backported install-wizard-connect.patch.
* Add Suggests: python-zbar and update the installation hint to suggest
  apt-get instead of pip (closes: #819517).
* Bump Standards-Version to 3.9.7 (no changes).
* Update Vcs-* links.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gui/kivy/tools/.buildozer/android/platform/python-for-android/dist/kivy/python-install/lib/python2.7/fileinput.py
 
1
"""Helper class to quickly write a loop over all standard input files.
 
2
 
 
3
Typical use is:
 
4
 
 
5
    import fileinput
 
6
    for line in fileinput.input():
 
7
        process(line)
 
8
 
 
9
This iterates over the lines of all files listed in sys.argv[1:],
 
10
defaulting to sys.stdin if the list is empty.  If a filename is '-' it
 
11
is also replaced by sys.stdin.  To specify an alternative list of
 
12
filenames, pass it as the argument to input().  A single file name is
 
13
also allowed.
 
14
 
 
15
Functions filename(), lineno() return the filename and cumulative line
 
16
number of the line that has just been read; filelineno() returns its
 
17
line number in the current file; isfirstline() returns true iff the
 
18
line just read is the first line of its file; isstdin() returns true
 
19
iff the line was read from sys.stdin.  Function nextfile() closes the
 
20
current file so that the next iteration will read the first line from
 
21
the next file (if any); lines not read from the file will not count
 
22
towards the cumulative line count; the filename is not changed until
 
23
after the first line of the next file has been read.  Function close()
 
24
closes the sequence.
 
25
 
 
26
Before any lines have been read, filename() returns None and both line
 
27
numbers are zero; nextfile() has no effect.  After all lines have been
 
28
read, filename() and the line number functions return the values
 
29
pertaining to the last line read; nextfile() has no effect.
 
30
 
 
31
All files are opened in text mode by default, you can override this by
 
32
setting the mode parameter to input() or FileInput.__init__().
 
33
If an I/O error occurs during opening or reading a file, the IOError
 
34
exception is raised.
 
35
 
 
36
If sys.stdin is used more than once, the second and further use will
 
37
return no lines, except perhaps for interactive use, or if it has been
 
38
explicitly reset (e.g. using sys.stdin.seek(0)).
 
39
 
 
40
Empty files are opened and immediately closed; the only time their
 
41
presence in the list of filenames is noticeable at all is when the
 
42
last file opened is empty.
 
43
 
 
44
It is possible that the last line of a file doesn't end in a newline
 
45
character; otherwise lines are returned including the trailing
 
46
newline.
 
47
 
 
48
Class FileInput is the implementation; its methods filename(),
 
49
lineno(), fileline(), isfirstline(), isstdin(), nextfile() and close()
 
50
correspond to the functions in the module.  In addition it has a
 
51
readline() method which returns the next input line, and a
 
52
__getitem__() method which implements the sequence behavior.  The
 
53
sequence must be accessed in strictly sequential order; sequence
 
54
access and readline() cannot be mixed.
 
55
 
 
56
Optional in-place filtering: if the keyword argument inplace=1 is
 
57
passed to input() or to the FileInput constructor, the file is moved
 
58
to a backup file and standard output is directed to the input file.
 
59
This makes it possible to write a filter that rewrites its input file
 
60
in place.  If the keyword argument backup=".<some extension>" is also
 
61
given, it specifies the extension for the backup file, and the backup
 
62
file remains around; by default, the extension is ".bak" and it is
 
63
deleted when the output file is closed.  In-place filtering is
 
64
disabled when standard input is read.  XXX The current implementation
 
65
does not work for MS-DOS 8+3 filesystems.
 
66
 
 
67
Performance: this module is unfortunately one of the slower ways of
 
68
processing large numbers of input lines.  Nevertheless, a significant
 
69
speed-up has been obtained by using readlines(bufsize) instead of
 
70
readline().  A new keyword argument, bufsize=N, is present on the
 
71
input() function and the FileInput() class to override the default
 
72
buffer size.
 
73
 
 
74
XXX Possible additions:
 
75
 
 
76
- optional getopt argument processing
 
77
- isatty()
 
78
- read(), read(size), even readlines()
 
79
 
 
80
"""
 
81
 
 
82
import sys, os
 
83
 
 
84
__all__ = ["input","close","nextfile","filename","lineno","filelineno",
 
85
           "isfirstline","isstdin","FileInput"]
 
86
 
 
87
_state = None
 
88
 
 
89
DEFAULT_BUFSIZE = 8*1024
 
90
 
 
91
def input(files=None, inplace=0, backup="", bufsize=0,
 
92
          mode="r", openhook=None):
 
93
    """input([files[, inplace[, backup[, mode[, openhook]]]]])
 
94
 
 
95
    Create an instance of the FileInput class. The instance will be used
 
96
    as global state for the functions of this module, and is also returned
 
97
    to use during iteration. The parameters to this function will be passed
 
98
    along to the constructor of the FileInput class.
 
99
    """
 
100
    global _state
 
101
    if _state and _state._file:
 
102
        raise RuntimeError, "input() already active"
 
103
    _state = FileInput(files, inplace, backup, bufsize, mode, openhook)
 
104
    return _state
 
105
 
 
106
def close():
 
107
    """Close the sequence."""
 
108
    global _state
 
109
    state = _state
 
110
    _state = None
 
111
    if state:
 
112
        state.close()
 
113
 
 
114
def nextfile():
 
115
    """
 
116
    Close the current file so that the next iteration will read the first
 
117
    line from the next file (if any); lines not read from the file will
 
118
    not count towards the cumulative line count. The filename is not
 
119
    changed until after the first line of the next file has been read.
 
120
    Before the first line has been read, this function has no effect;
 
121
    it cannot be used to skip the first file. After the last line of the
 
122
    last file has been read, this function has no effect.
 
123
    """
 
124
    if not _state:
 
125
        raise RuntimeError, "no active input()"
 
126
    return _state.nextfile()
 
127
 
 
128
def filename():
 
129
    """
 
130
    Return the name of the file currently being read.
 
131
    Before the first line has been read, returns None.
 
132
    """
 
133
    if not _state:
 
134
        raise RuntimeError, "no active input()"
 
135
    return _state.filename()
 
136
 
 
137
def lineno():
 
138
    """
 
139
    Return the cumulative line number of the line that has just been read.
 
140
    Before the first line has been read, returns 0. After the last line
 
141
    of the last file has been read, returns the line number of that line.
 
142
    """
 
143
    if not _state:
 
144
        raise RuntimeError, "no active input()"
 
145
    return _state.lineno()
 
146
 
 
147
def filelineno():
 
148
    """
 
149
    Return the line number in the current file. Before the first line
 
150
    has been read, returns 0. After the last line of the last file has
 
151
    been read, returns the line number of that line within the file.
 
152
    """
 
153
    if not _state:
 
154
        raise RuntimeError, "no active input()"
 
155
    return _state.filelineno()
 
156
 
 
157
def fileno():
 
158
    """
 
159
    Return the file number of the current file. When no file is currently
 
160
    opened, returns -1.
 
161
    """
 
162
    if not _state:
 
163
        raise RuntimeError, "no active input()"
 
164
    return _state.fileno()
 
165
 
 
166
def isfirstline():
 
167
    """
 
168
    Returns true the line just read is the first line of its file,
 
169
    otherwise returns false.
 
170
    """
 
171
    if not _state:
 
172
        raise RuntimeError, "no active input()"
 
173
    return _state.isfirstline()
 
174
 
 
175
def isstdin():
 
176
    """
 
177
    Returns true if the last line was read from sys.stdin,
 
178
    otherwise returns false.
 
179
    """
 
180
    if not _state:
 
181
        raise RuntimeError, "no active input()"
 
182
    return _state.isstdin()
 
183
 
 
184
class FileInput:
 
185
    """class FileInput([files[, inplace[, backup[, mode[, openhook]]]]])
 
186
 
 
187
    Class FileInput is the implementation of the module; its methods
 
188
    filename(), lineno(), fileline(), isfirstline(), isstdin(), fileno(),
 
189
    nextfile() and close() correspond to the functions of the same name
 
190
    in the module.
 
191
    In addition it has a readline() method which returns the next
 
192
    input line, and a __getitem__() method which implements the
 
193
    sequence behavior. The sequence must be accessed in strictly
 
194
    sequential order; random access and readline() cannot be mixed.
 
195
    """
 
196
 
 
197
    def __init__(self, files=None, inplace=0, backup="", bufsize=0,
 
198
                 mode="r", openhook=None):
 
199
        if isinstance(files, basestring):
 
200
            files = (files,)
 
201
        else:
 
202
            if files is None:
 
203
                files = sys.argv[1:]
 
204
            if not files:
 
205
                files = ('-',)
 
206
            else:
 
207
                files = tuple(files)
 
208
        self._files = files
 
209
        self._inplace = inplace
 
210
        self._backup = backup
 
211
        self._bufsize = bufsize or DEFAULT_BUFSIZE
 
212
        self._savestdout = None
 
213
        self._output = None
 
214
        self._filename = None
 
215
        self._lineno = 0
 
216
        self._filelineno = 0
 
217
        self._file = None
 
218
        self._isstdin = False
 
219
        self._backupfilename = None
 
220
        self._buffer = []
 
221
        self._bufindex = 0
 
222
        # restrict mode argument to reading modes
 
223
        if mode not in ('r', 'rU', 'U', 'rb'):
 
224
            raise ValueError("FileInput opening mode must be one of "
 
225
                             "'r', 'rU', 'U' and 'rb'")
 
226
        self._mode = mode
 
227
        if inplace and openhook:
 
228
            raise ValueError("FileInput cannot use an opening hook in inplace mode")
 
229
        elif openhook and not hasattr(openhook, '__call__'):
 
230
            raise ValueError("FileInput openhook must be callable")
 
231
        self._openhook = openhook
 
232
 
 
233
    def __del__(self):
 
234
        self.close()
 
235
 
 
236
    def close(self):
 
237
        self.nextfile()
 
238
        self._files = ()
 
239
 
 
240
    def __iter__(self):
 
241
        return self
 
242
 
 
243
    def next(self):
 
244
        try:
 
245
            line = self._buffer[self._bufindex]
 
246
        except IndexError:
 
247
            pass
 
248
        else:
 
249
            self._bufindex += 1
 
250
            self._lineno += 1
 
251
            self._filelineno += 1
 
252
            return line
 
253
        line = self.readline()
 
254
        if not line:
 
255
            raise StopIteration
 
256
        return line
 
257
 
 
258
    def __getitem__(self, i):
 
259
        if i != self._lineno:
 
260
            raise RuntimeError, "accessing lines out of order"
 
261
        try:
 
262
            return self.next()
 
263
        except StopIteration:
 
264
            raise IndexError, "end of input reached"
 
265
 
 
266
    def nextfile(self):
 
267
        savestdout = self._savestdout
 
268
        self._savestdout = 0
 
269
        if savestdout:
 
270
            sys.stdout = savestdout
 
271
 
 
272
        output = self._output
 
273
        self._output = 0
 
274
        if output:
 
275
            output.close()
 
276
 
 
277
        file = self._file
 
278
        self._file = 0
 
279
        if file and not self._isstdin:
 
280
            file.close()
 
281
 
 
282
        backupfilename = self._backupfilename
 
283
        self._backupfilename = 0
 
284
        if backupfilename and not self._backup:
 
285
            try: os.unlink(backupfilename)
 
286
            except OSError: pass
 
287
 
 
288
        self._isstdin = False
 
289
        self._buffer = []
 
290
        self._bufindex = 0
 
291
 
 
292
    def readline(self):
 
293
        try:
 
294
            line = self._buffer[self._bufindex]
 
295
        except IndexError:
 
296
            pass
 
297
        else:
 
298
            self._bufindex += 1
 
299
            self._lineno += 1
 
300
            self._filelineno += 1
 
301
            return line
 
302
        if not self._file:
 
303
            if not self._files:
 
304
                return ""
 
305
            self._filename = self._files[0]
 
306
            self._files = self._files[1:]
 
307
            self._filelineno = 0
 
308
            self._file = None
 
309
            self._isstdin = False
 
310
            self._backupfilename = 0
 
311
            if self._filename == '-':
 
312
                self._filename = '<stdin>'
 
313
                self._file = sys.stdin
 
314
                self._isstdin = True
 
315
            else:
 
316
                if self._inplace:
 
317
                    self._backupfilename = (
 
318
                        self._filename + (self._backup or os.extsep+"bak"))
 
319
                    try: os.unlink(self._backupfilename)
 
320
                    except os.error: pass
 
321
                    # The next few lines may raise IOError
 
322
                    os.rename(self._filename, self._backupfilename)
 
323
                    self._file = open(self._backupfilename, self._mode)
 
324
                    try:
 
325
                        perm = os.fstat(self._file.fileno()).st_mode
 
326
                    except OSError:
 
327
                        self._output = open(self._filename, "w")
 
328
                    else:
 
329
                        fd = os.open(self._filename,
 
330
                                     os.O_CREAT | os.O_WRONLY | os.O_TRUNC,
 
331
                                     perm)
 
332
                        self._output = os.fdopen(fd, "w")
 
333
                        try:
 
334
                            if hasattr(os, 'chmod'):
 
335
                                os.chmod(self._filename, perm)
 
336
                        except OSError:
 
337
                            pass
 
338
                    self._savestdout = sys.stdout
 
339
                    sys.stdout = self._output
 
340
                else:
 
341
                    # This may raise IOError
 
342
                    if self._openhook:
 
343
                        self._file = self._openhook(self._filename, self._mode)
 
344
                    else:
 
345
                        self._file = open(self._filename, self._mode)
 
346
        self._buffer = self._file.readlines(self._bufsize)
 
347
        self._bufindex = 0
 
348
        if not self._buffer:
 
349
            self.nextfile()
 
350
        # Recursive call
 
351
        return self.readline()
 
352
 
 
353
    def filename(self):
 
354
        return self._filename
 
355
 
 
356
    def lineno(self):
 
357
        return self._lineno
 
358
 
 
359
    def filelineno(self):
 
360
        return self._filelineno
 
361
 
 
362
    def fileno(self):
 
363
        if self._file:
 
364
            try:
 
365
                return self._file.fileno()
 
366
            except ValueError:
 
367
                return -1
 
368
        else:
 
369
            return -1
 
370
 
 
371
    def isfirstline(self):
 
372
        return self._filelineno == 1
 
373
 
 
374
    def isstdin(self):
 
375
        return self._isstdin
 
376
 
 
377
 
 
378
def hook_compressed(filename, mode):
 
379
    ext = os.path.splitext(filename)[1]
 
380
    if ext == '.gz':
 
381
        import gzip
 
382
        return gzip.open(filename, mode)
 
383
    elif ext == '.bz2':
 
384
        import bz2
 
385
        return bz2.BZ2File(filename, mode)
 
386
    else:
 
387
        return open(filename, mode)
 
388
 
 
389
 
 
390
def hook_encoded(encoding):
 
391
    import codecs
 
392
    def openhook(filename, mode):
 
393
        return codecs.open(filename, mode, encoding)
 
394
    return openhook
 
395
 
 
396
 
 
397
def _test():
 
398
    import getopt
 
399
    inplace = 0
 
400
    backup = 0
 
401
    opts, args = getopt.getopt(sys.argv[1:], "ib:")
 
402
    for o, a in opts:
 
403
        if o == '-i': inplace = 1
 
404
        if o == '-b': backup = a
 
405
    for line in input(args, inplace=inplace, backup=backup):
 
406
        if line[-1:] == '\n': line = line[:-1]
 
407
        if line[-1:] == '\r': line = line[:-1]
 
408
        print "%d: %s[%d]%s %s" % (lineno(), filename(), filelineno(),
 
409
                                   isfirstline() and "*" or "", line)
 
410
    print "%d: %s[%d]" % (lineno(), filename(), filelineno())
 
411
 
 
412
if __name__ == '__main__':
 
413
    _test()