Lines Matching refs:self
37 def __init__(self, path, factory=None, create=True):
39 self._path = os.path.abspath(os.path.expanduser(path))
40 self._factory = factory
42 def add(self, message):
46 def remove(self, key):
50 def __delitem__(self, key):
51 self.remove(key)
53 def discard(self, key):
56 self.remove(key)
60 def __setitem__(self, key, message):
64 def get(self, key, default=None):
67 return self.__getitem__(key)
71 def __getitem__(self, key):
73 if not self._factory:
74 return self.get_message(key)
76 with contextlib.closing(self.get_file(key)) as file:
77 return self._factory(file)
79 def get_message(self, key):
83 def get_string(self, key):
88 return email.message_from_bytes(self.get_bytes(key)).as_string()
90 def get_bytes(self, key):
94 def get_file(self, key):
98 def iterkeys(self):
102 def keys(self):
104 return list(self.iterkeys())
106 def itervalues(self):
108 for key in self.iterkeys():
110 value = self[key]
115 def __iter__(self):
116 return self.itervalues()
118 def values(self):
120 return list(self.itervalues())
122 def iteritems(self):
124 for key in self.iterkeys():
126 value = self[key]
131 def items(self):
133 return list(self.iteritems())
135 def __contains__(self, key):
139 def __len__(self):
143 def clear(self):
145 for key in self.keys():
146 self.discard(key)
148 def pop(self, key, default=None):
151 result = self[key]
154 self.discard(key)
157 def popitem(self):
159 for key in self.iterkeys():
160 return (key, self.pop(key)) # This is only run once.
164 def update(self, arg=None):
175 self[key] = message
181 def flush(self):
185 def lock(self):
189 def unlock(self):
193 def close(self):
197 def _string_to_bytes(self, message):
210 def _dump_message(self, message, target, mangle_from_=False):
221 if self._append_newline and not data.endswith(linesep):
230 message = self._string_to_bytes(message)
235 if self._append_newline and not message.endswith(linesep):
258 if self._append_newline and lastline and not lastline.endswith(linesep):
272 def __init__(self, dirname, factory=None, create=True):
274 Mailbox.__init__(self, dirname, factory, create)
275 self._paths = {
276 'tmp': os.path.join(self._path, 'tmp'),
277 'new': os.path.join(self._path, 'new'),
278 'cur': os.path.join(self._path, 'cur'),
280 if not os.path.exists(self._path):
282 os.mkdir(self._path, 0o700)
283 for path in self._paths.values():
286 raise NoSuchMailboxError(self._path)
287 self._toc = {}
288 self._toc_mtimes = {'cur': 0, 'new': 0}
289 self._last_read = 0 # Records last time we read cur/new
290 self._skewfactor = 0.1 # Adjust if os/fs clocks are skewing
292 def add(self, message):
294 tmp_file = self._create_tmp()
296 self._dump_message(message, tmp_file)
304 suffix = self.colon + message.get_info()
305 if suffix == self.colon:
310 uniq = os.path.basename(tmp_file.name).split(self.colon)[0]
311 dest = os.path.join(self._path, subdir, uniq + suffix)
334 def remove(self, key):
336 os.remove(os.path.join(self._path, self._lookup(key)))
338 def discard(self, key):
342 self.remove(key)
346 def __setitem__(self, key, message):
348 old_subpath = self._lookup(key)
349 temp_key = self.add(message)
350 temp_subpath = self._lookup(temp_key)
358 if self.colon in dominant_subpath:
359 suffix = self.colon + dominant_subpath.split(self.colon)[-1]
362 self.discard(key)
363 tmp_path = os.path.join(self._path, temp_subpath)
364 new_path = os.path.join(self._path, subdir, key + suffix)
373 def get_message(self, key):
375 subpath = self._lookup(key)
376 with open(os.path.join(self._path, subpath), 'rb') as f:
377 if self._factory:
378 msg = self._factory(f)
383 if self.colon in name:
384 msg.set_info(name.split(self.colon)[-1])
385 msg.set_date(os.path.getmtime(os.path.join(self._path, subpath)))
388 def get_bytes(self, key):
390 with open(os.path.join(self._path, self._lookup(key)), 'rb') as f:
393 def get_file(self, key):
395 f = open(os.path.join(self._path, self._lookup(key)), 'rb')
398 def iterkeys(self):
400 self._refresh()
401 for key in self._toc:
403 self._lookup(key)
408 def __contains__(self, key):
410 self._refresh()
411 return key in self._toc
413 def __len__(self):
415 self._refresh()
416 return len(self._toc)
418 def flush(self):
424 def lock(self):
428 def unlock(self):
432 def close(self):
436 def list_folders(self):
439 for entry in os.listdir(self._path):
441 os.path.isdir(os.path.join(self._path, entry)):
445 def get_folder(self, folder):
447 return Maildir(os.path.join(self._path, '.' + folder),
448 factory=self._factory,
451 def add_folder(self, folder):
453 path = os.path.join(self._path, '.' + folder)
454 result = Maildir(path, factory=self._factory)
461 def remove_folder(self, folder):
463 path = os.path.join(self._path, '.' + folder)
480 def clean(self):
483 for entry in os.listdir(os.path.join(self._path, 'tmp')):
484 path = os.path.join(self._path, 'tmp', entry)
490 def _create_tmp(self):
500 path = os.path.join(self._path, 'tmp', uniq)
514 def _refresh(self):
529 if time.time() - self._last_read > 2 + self._skewfactor:
531 for subdir in self._toc_mtimes:
532 mtime = os.path.getmtime(self._paths[subdir])
533 if mtime > self._toc_mtimes[subdir]:
535 self._toc_mtimes[subdir] = mtime
539 self._toc = {}
540 for subdir in self._toc_mtimes:
541 path = self._paths[subdir]
546 uniq = entry.split(self.colon)[0]
547 self._toc[uniq] = os.path.join(subdir, entry)
548 self._last_read = time.time()
550 def _lookup(self, key):
553 if os.path.exists(os.path.join(self._path, self._toc[key])):
554 return self._toc[key]
557 self._refresh()
559 return self._toc[key]
564 def next(self):
566 if not hasattr(self, '_onetime_keys'):
567 self._onetime_keys = self.iterkeys()
570 return self[next(self._onetime_keys)]
580 def __init__(self, path, factory=None, create=True):
582 Mailbox.__init__(self, path, factory, create)
584 f = open(self._path, 'rb+')
588 f = open(self._path, 'wb+')
590 raise NoSuchMailboxError(self._path)
592 f = open(self._path, 'rb')
595 self._file = f
596 self._toc = None
597 self._next_key = 0
598 self._pending = False # No changes require rewriting the file.
599 self._pending_sync = False # No need to sync the file
600 self._locked = False
601 self._file_length = None # Used to record mailbox size
603 def add(self, message):
605 self._lookup()
606 self._toc[self._next_key] = self._append_message(message)
607 self._next_key += 1
610 self._pending_sync = True
611 return self._next_key - 1
613 def remove(self, key):
615 self._lookup(key)
616 del self._toc[key]
617 self._pending = True
619 def __setitem__(self, key, message):
621 self._lookup(key)
622 self._toc[key] = self._append_message(message)
623 self._pending = True
625 def iterkeys(self):
627 self._lookup()
628 yield from self._toc.keys()
630 def __contains__(self, key):
632 self._lookup()
633 return key in self._toc
635 def __len__(self):
637 self._lookup()
638 return len(self._toc)
640 def lock(self):
642 if not self._locked:
643 _lock_file(self._file)
644 self._locked = True
646 def unlock(self):
648 if self._locked:
649 _unlock_file(self._file)
650 self._locked = False
652 def flush(self):
654 if not self._pending:
655 if self._pending_sync:
658 _sync_flush(self._file)
659 self._pending_sync = False
662 # In order to be writing anything out at all, self._toc must
665 assert self._toc is not None
667 # Check length of self._file; if it's changed, some other process
669 self._file.seek(0, 2)
670 cur_len = self._file.tell()
671 if cur_len != self._file_length:
674 (self._file_length, cur_len))
676 new_file = _create_temporary(self._path)
679 self._pre_mailbox_hook(new_file)
680 for key in sorted(self._toc.keys()):
681 start, stop = self._toc[key]
682 self._file.seek(start)
683 self._pre_message_hook(new_file)
686 buffer = self._file.read(min(4096,
687 stop - self._file.tell()))
692 self._post_message_hook(new_file)
693 self._file_length = new_file.tell()
699 # self._file is about to get replaced, so no need to sync.
700 self._file.close()
702 mode = os.stat(self._path).st_mode
705 os.rename(new_file.name, self._path)
707 os.remove(self._path)
708 os.rename(new_file.name, self._path)
709 self._file = open(self._path, 'rb+')
710 self._toc = new_toc
711 self._pending = False
712 self._pending_sync = False
713 if self._locked:
714 _lock_file(self._file, dotlock=False)
716 def _pre_mailbox_hook(self, f):
720 def _pre_message_hook(self, f):
724 def _post_message_hook(self, f):
728 def close(self):
731 self.flush()
734 if self._locked:
735 self.unlock()
737 self._file.close() # Sync has been done by self.flush() above.
739 def _lookup(self, key=None):
741 if self._toc is None:
742 self._generate_toc()
745 return self._toc[key]
749 def _append_message(self, message):
751 self._file.seek(0, 2)
752 before = self._file.tell()
753 if len(self._toc) == 0 and not self._pending:
755 # hasn't yet been called. If self._pending is True,
758 self._pre_mailbox_hook(self._file)
760 self._pre_message_hook(self._file)
761 offsets = self._install_message(message)
762 self._post_message_hook(self._file)
764 self._file.truncate(before)
766 self._file.flush()
767 self._file_length = self._file.tell() # Record current length of mailbox
777 def get_message(self, key):
779 start, stop = self._lookup(key)
780 self._file.seek(start)
781 from_line = self._file.readline().replace(linesep, b'')
782 string = self._file.read(stop - self._file.tell())
783 msg = self._message_factory(string.replace(linesep, b'\n'))
787 def get_string(self, key, from_=False):
790 self.get_bytes(key, from_)).as_string(unixfrom=from_)
792 def get_bytes(self, key, from_=False):
794 start, stop = self._lookup(key)
795 self._file.seek(start)
797 self._file.readline()
798 string = self._file.read(stop - self._file.tell())
801 def get_file(self, key, from_=False):
803 start, stop = self._lookup(key)
804 self._file.seek(start)
806 self._file.readline()
807 return _PartialFile(self._file, self._file.tell(), stop)
809 def _install_message(self, message):
810 """Format a message and blindly write to self._file."""
813 message = self._string_to_bytes(message)
831 start = self._file.tell()
832 self._file.write(from_line + linesep)
833 self._dump_message(message, self._file, self._mangle_from_)
834 stop = self._file.tell()
847 def __init__(self, path, factory=None, create=True):
849 self._message_factory = mboxMessage
850 _mboxMMDF.__init__(self, path, factory, create)
852 def _post_message_hook(self, f):
856 def _generate_toc(self):
860 self._file.seek(0)
862 line_pos = self._file.tell()
863 line = self._file.readline()
885 self._toc = dict(enumerate(zip(starts, stops)))
886 self._next_key = len(self._toc)
887 self._file_length = self._file.tell()
893 def __init__(self, path, factory=None, create=True):
895 self._message_factory = MMDFMessage
896 _mboxMMDF.__init__(self, path, factory, create)
898 def _pre_message_hook(self, f):
902 def _post_message_hook(self, f):
906 def _generate_toc(self):
909 self._file.seek(0)
913 line = self._file.readline()
914 next_pos = self._file.tell()
919 line = self._file.readline()
920 next_pos = self._file.tell()
929 self._toc = dict(enumerate(zip(starts, stops)))
930 self._next_key = len(self._toc)
931 self._file.seek(0, 2)
932 self._file_length = self._file.tell()
938 def __init__(self, path, factory=None, create=True):
940 Mailbox.__init__(self, path, factory, create)
941 if not os.path.exists(self._path):
943 os.mkdir(self._path, 0o700)
944 os.close(os.open(os.path.join(self._path, '.mh_sequences'),
947 raise NoSuchMailboxError(self._path)
948 self._locked = False
950 def add(self, message):
952 keys = self.keys()
957 new_path = os.path.join(self._path, str(new_key))
961 if self._locked:
965 self._dump_message(message, f)
968 if self._locked:
975 self._dump_sequences(message, new_key)
977 if self._locked:
984 def remove(self, key):
986 path = os.path.join(self._path, str(key))
998 def __setitem__(self, key, message):
1000 path = os.path.join(self._path, str(key))
1009 if self._locked:
1013 self._dump_message(message, f)
1015 self._dump_sequences(message, key)
1017 if self._locked:
1022 def get_message(self, key):
1025 if self._locked:
1026 f = open(os.path.join(self._path, str(key)), 'rb+')
1028 f = open(os.path.join(self._path, str(key)), 'rb')
1035 if self._locked:
1040 if self._locked:
1042 for name, key_list in self.get_sequences().items():
1047 def get_bytes(self, key):
1050 if self._locked:
1051 f = open(os.path.join(self._path, str(key)), 'rb+')
1053 f = open(os.path.join(self._path, str(key)), 'rb')
1060 if self._locked:
1065 if self._locked:
1068 def get_file(self, key):
1071 f = open(os.path.join(self._path, str(key)), 'rb')
1079 def iterkeys(self):
1081 return iter(sorted(int(entry) for entry in os.listdir(self._path)
1084 def __contains__(self, key):
1086 return os.path.exists(os.path.join(self._path, str(key)))
1088 def __len__(self):
1090 return len(list(self.iterkeys()))
1092 def lock(self):
1094 if not self._locked:
1095 self._file = open(os.path.join(self._path, '.mh_sequences'), 'rb+')
1096 _lock_file(self._file)
1097 self._locked = True
1099 def unlock(self):
1101 if self._locked:
1102 _unlock_file(self._file)
1103 _sync_close(self._file)
1104 del self._file
1105 self._locked = False
1107 def flush(self):
1111 def close(self):
1113 if self._locked:
1114 self.unlock()
1116 def list_folders(self):
1119 for entry in os.listdir(self._path):
1120 if os.path.isdir(os.path.join(self._path, entry)):
1124 def get_folder(self, folder):
1126 return MH(os.path.join(self._path, folder),
1127 factory=self._factory, create=False)
1129 def add_folder(self, folder):
1131 return MH(os.path.join(self._path, folder),
1132 factory=self._factory)
1134 def remove_folder(self, folder):
1136 path = os.path.join(self._path, folder)
1143 raise NotEmptyError('Folder not empty: %s' % self._path)
1146 def get_sequences(self):
1149 with open(os.path.join(self._path, '.mh_sequences'), 'r', encoding='ASCII') as f:
1150 all_keys = set(self.keys())
1170 def set_sequences(self, sequences):
1172 f = open(os.path.join(self._path, '.mh_sequences'), 'r+', encoding='ASCII')
1199 def pack(self):
1201 sequences = self.get_sequences()
1204 for key in self.iterkeys():
1208 os.link(os.path.join(self._path, str(key)),
1209 os.path.join(self._path, str(prev + 1)))
1211 os.rename(os.path.join(self._path, str(key)),
1212 os.path.join(self._path, str(prev + 1)))
1214 os.unlink(os.path.join(self._path, str(key)))
1216 self._next_key = prev + 1
1223 self.set_sequences(sequences)
1225 def _dump_sequences(self, message, key):
1228 all_sequences = self.get_sequences()
1237 self.set_sequences(all_sequences)
1246 def __init__(self, path, factory=None, create=True):
1248 _singlefileMailbox.__init__(self, path, factory, create)
1249 self._labels = {}
1251 def add(self, message):
1253 key = _singlefileMailbox.add(self, message)
1255 self._labels[key] = message.get_labels()
1258 def remove(self, key):
1260 _singlefileMailbox.remove(self, key)
1261 if key in self._labels:
1262 del self._labels[key]
1264 def __setitem__(self, key, message):
1266 _singlefileMailbox.__setitem__(self, key, message)
1268 self._labels[key] = message.get_labels()
1270 def get_message(self, key):
1272 start, stop = self._lookup(key)
1273 self._file.seek(start)
1274 self._file.readline() # Skip b'1,' line specifying labels.
1277 line = self._file.readline()
1283 line = self._file.readline()
1288 n = stop - self._file.tell()
1290 body = self._file.read(n)
1294 if key in self._labels:
1295 msg.set_labels(self._labels[key])
1298 def get_bytes(self, key):
1300 start, stop = self._lookup(key)
1301 self._file.seek(start)
1302 self._file.readline() # Skip b'1,' line specifying labels.
1305 line = self._file.readline()
1310 line = self._file.readline()
1314 n = stop - self._file.tell()
1316 data = self._file.read(n)
1320 def get_file(self, key):
1322 return io.BytesIO(self.get_bytes(key).replace(b'\n', linesep))
1324 def get_labels(self):
1326 self._lookup()
1328 for label_list in self._labels.values():
1330 labels.difference_update(self._special_labels)
1333 def _generate_toc(self):
1336 self._file.seek(0)
1341 line = self._file.readline()
1342 next_pos = self._file.tell()
1348 in self._file.readline()[1:].split(b',')
1357 self._toc = dict(enumerate(zip(starts, stops)))
1358 self._labels = dict(enumerate(label_lists))
1359 self._next_key = len(self._toc)
1360 self._file.seek(0, 2)
1361 self._file_length = self._file.tell()
1363 def _pre_mailbox_hook(self, f):
1367 labels = self.get_labels()
1373 def _pre_message_hook(self, f):
1377 def _post_message_hook(self, f):
1381 def _install_message(self, message):
1383 start = self._file.tell()
1388 if label in self._special_labels:
1392 self._file.write(b'1')
1394 self._file.write(b', ' + label.encode())
1395 self._file.write(b',,')
1397 self._file.write(b' ' + label.encode() + b',')
1398 self._file.write(linesep)
1400 self._file.write(b'1,,' + linesep)
1408 self._file.write(line.replace(b'\n', linesep))
1411 self._file.write(b'*** EOOH ***' + linesep)
1418 self._file.write(line.replace(b'\n', linesep))
1425 self._file.write(line.replace(b'\n', linesep))
1432 self._file.write(buffer.replace(b'\n', linesep))
1439 message = self._string_to_bytes(message)
1442 self._file.write(message[:body_start].replace(b'\n', linesep))
1443 self._file.write(b'*** EOOH ***' + linesep)
1444 self._file.write(message[:body_start].replace(b'\n', linesep))
1445 self._file.write(message[body_start:].replace(b'\n', linesep))
1447 self._file.write(b'*** EOOH ***' + linesep + linesep)
1448 self._file.write(message.replace(b'\n', linesep))
1463 self._file.write(line.replace(b'\n', linesep))
1467 self._file.write(b'*** EOOH ***' + linesep)
1482 self._file.write(line)
1485 stop = self._file.tell()
1492 def __init__(self, message=None):
1495 self._become_message(copy.deepcopy(message))
1497 message._explain_to(self)
1499 self._become_message(email.message_from_bytes(message))
1501 self._become_message(email.message_from_string(message))
1503 self._become_message(email.message_from_file(message))
1505 self._become_message(email.message_from_binary_file(message))
1507 email.message.Message.__init__(self)
1511 def _become_message(self, message):
1516 self.__dict__[name] = message.__dict__[name]
1518 def _explain_to(self, message):
1531 def __init__(self, message=None):
1533 self._subdir = 'new'
1534 self._info = ''
1535 self._date = time.time()
1536 Message.__init__(self, message)
1538 def get_subdir(self):
1540 return self._subdir
1542 def set_subdir(self, subdir):
1545 self._subdir = subdir
1549 def get_flags(self):
1551 if self._info.startswith('2,'):
1552 return self._info[2:]
1556 def set_flags(self, flags):
1558 self._info = '2,' + ''.join(sorted(flags))
1560 def add_flag(self, flag):
1562 self.set_flags(''.join(set(self.get_flags()) | set(flag)))
1564 def remove_flag(self, flag):
1566 if self.get_flags():
1567 self.set_flags(''.join(set(self.get_flags()) - set(flag)))
1569 def get_date(self):
1571 return self._date
1573 def set_date(self, date):
1576 self._date = float(date)
1580 def get_info(self):
1582 return self._info
1584 def set_info(self, info):
1587 self._info = info
1591 def _explain_to(self, message):
1594 message.set_flags(self.get_flags())
1595 message.set_subdir(self.get_subdir())
1596 message.set_date(self.get_date())
1598 flags = set(self.get_flags())
1601 if self.get_subdir() == 'cur':
1609 message.set_from('MAILER-DAEMON', time.gmtime(self.get_date()))
1611 flags = set(self.get_flags())
1619 flags = set(self.get_flags())
1640 def __init__(self, message=None):
1642 self.set_from('MAILER-DAEMON', True)
1646 self.set_from(unixfrom[5:])
1647 Message.__init__(self, message)
1649 def get_from(self):
1651 return self._from
1653 def set_from(self, from_, time_=None):
1659 self._from = from_
1661 def get_flags(self):
1663 return self.get('Status', '') + self.get('X-Status', '')
1665 def set_flags(self, flags):
1679 self.replace_header('Status', status_flags)
1681 self.add_header('Status', status_flags)
1683 self.replace_header('X-Status', xstatus_flags)
1685 self.add_header('X-Status', xstatus_flags)
1687 def add_flag(self, flag):
1689 self.set_flags(''.join(set(self.get_flags()) | set(flag)))
1691 def remove_flag(self, flag):
1693 if 'Status' in self or 'X-Status' in self:
1694 self.set_flags(''.join(set(self.get_flags()) - set(flag)))
1696 def _explain_to(self, message):
1699 flags = set(self.get_flags())
1712 maybe_date = ' '.join(self.get_from().split()[-5:])
1719 message.set_flags(self.get_flags())
1720 message.set_from(self.get_from())
1722 flags = set(self.get_flags())
1732 flags = set(self.get_flags())
1757 def __init__(self, message=None):
1759 self._sequences = []
1760 Message.__init__(self, message)
1762 def get_sequences(self):
1764 return self._sequences[:]
1766 def set_sequences(self, sequences):
1768 self._sequences = list(sequences)
1770 def add_sequence(self, sequence):
1773 if not sequence in self._sequences:
1774 self._sequences.append(sequence)
1778 def remove_sequence(self, sequence):
1781 self._sequences.remove(sequence)
1785 def _explain_to(self, message):
1788 sequences = set(self.get_sequences())
1799 sequences = set(self.get_sequences())
1809 for sequence in self.get_sequences():
1812 sequences = set(self.get_sequences())
1829 def __init__(self, message=None):
1831 self._labels = []
1832 self._visible = Message()
1833 Message.__init__(self, message)
1835 def get_labels(self):
1837 return self._labels[:]
1839 def set_labels(self, labels):
1841 self._labels = list(labels)
1843 def add_label(self, label):
1846 if label not in self._labels:
1847 self._labels.append(label)
1851 def remove_label(self, label):
1854 self._labels.remove(label)
1858 def get_visible(self):
1860 return Message(self._visible)
1862 def set_visible(self, visible):
1864 self._visible = Message(visible)
1866 def update_visible(self):
1868 for header in self._visible.keys():
1869 if header in self:
1870 self._visible.replace_header(header, self[header])
1872 del self._visible[header]
1874 if header in self and header not in self._visible:
1875 self._visible[header] = self[header]
1877 def _explain_to(self, message):
1880 labels = set(self.get_labels())
1893 labels = set(self.get_labels())
1903 labels = set(self.get_labels())
1909 message.set_visible(self.get_visible())
1910 for label in self.get_labels():
1926 def __init__(self, f, pos=None):
1928 self._file = f
1930 self._pos = f.tell()
1932 self._pos = pos
1934 def read(self, size=None):
1936 return self._read(size, self._file.read)
1938 def read1(self, size=None):
1940 return self._read(size, self._file.read1)
1942 def readline(self, size=None):
1944 return self._read(size, self._file.readline)
1946 def readlines(self, sizehint=None):
1949 for line in self:
1957 def __iter__(self):
1960 line = self.readline()
1965 def tell(self):
1967 return self._pos
1969 def seek(self, offset, whence=0):
1972 self._file.seek(self._pos)
1973 self._file.seek(offset, whence)
1974 self._pos = self._file.tell()
1976 def close(self):
1978 if hasattr(self, '_file'):
1980 if hasattr(self._file, 'close'):
1981 self._file.close()
1983 del self._file
1985 def _read(self, size, read_method):
1989 self._file.seek(self._pos)
1991 self._pos = self._file.tell()
1994 def __enter__(self):
1996 return self
1998 def __exit__(self, *exc):
1999 self.close()
2001 def readable(self):
2002 return self._file.readable()
2004 def writable(self):
2005 return self._file.writable()
2007 def seekable(self):
2008 return self._file.seekable()
2010 def flush(self):
2011 return self._file.flush()
2014 def closed(self):
2015 if not hasattr(self, '_file'):
2017 if not hasattr(self._file, 'closed'):
2019 return self._file.closed
2027 def __init__(self, f, start=None, stop=None):
2029 _ProxyFile.__init__(self, f, start)
2030 self._start = start
2031 self._stop = stop
2033 def tell(self):
2035 return _ProxyFile.tell(self) - self._start
2037 def seek(self, offset, whence=0):
2040 self._pos = self._start
2043 self._pos = self._stop
2045 _ProxyFile.seek(self, offset, whence)
2047 def _read(self, size, read_method):
2049 remaining = self._stop - self._pos
2054 return _ProxyFile._read(self, size, read_method)
2056 def close(self):
2059 if hasattr(self, '_file'):
2060 del self._file