| class Range(object): |
| |
| """ |
| Represents the Range header. |
| |
| This only represents ``bytes`` ranges, which are the only kind |
| specified in HTTP. This can represent multiple sets of ranges, |
| but no place else is this multi-range facility supported. |
| """ |
| |
| def __init__(self, ranges): |
| for begin, end in ranges: |
| assert end is None or end >= 0, "Bad ranges: %r" % ranges |
| self.ranges = ranges |
| |
| def satisfiable(self, length): |
| """ |
| Returns true if this range can be satisfied by the resource |
| with the given byte length. |
| """ |
| for begin, end in self.ranges: |
| if end is not None and end >= length: |
| return False |
| return True |
| |
| def range_for_length(self, length): |
| """ |
| *If* there is only one range, and *if* it is satisfiable by |
| the given length, then return a (begin, end) non-inclusive range |
| of bytes to serve. Otherwise return None |
| |
| If length is None (unknown length), then the resulting range |
| may be (begin, None), meaning it should be served from that |
| point. If it's a range with a fixed endpoint we won't know if |
| it is satisfiable, so this will return None. |
| """ |
| if len(self.ranges) != 1: |
| return None |
| begin, end = self.ranges[0] |
| if length is None: |
| # Unknown; only works with ranges with no end-point |
| if end is None: |
| return (begin, end) |
| return None |
| if end >= length: |
| # Overshoots the end |
| return None |
| return (begin, end) |
| |
| def content_range(self, length): |
| """ |
| Works like range_for_length; returns None or a ContentRange object |
| |
| You can use it like:: |
| |
| response.content_range = req.range.content_range(response.content_length) |
| |
| Though it's still up to you to actually serve that content range! |
| """ |
| range = self.range_for_length(length) |
| if range is None: |
| return None |
| return ContentRange(range[0], range[1], length) |
| |
| def __str__(self): |
| return self.serialize_bytes('bytes', self.python_ranges_to_bytes(self.ranges)) |
| |
| def __repr__(self): |
| return '<%s ranges=%s>' % ( |
| self.__class__.__name__, |
| ', '.join(map(repr, self.ranges))) |
| |
| #@classmethod |
| def parse(cls, header): |
| """ |
| Parse the header; may return None if header is invalid |
| """ |
| bytes = cls.parse_bytes(header) |
| if bytes is None: |
| return None |
| units, ranges = bytes |
| if units.lower() != 'bytes': |
| return None |
| ranges = cls.bytes_to_python_ranges(ranges) |
| if ranges is None: |
| return None |
| return cls(ranges) |
| parse = classmethod(parse) |
| |
| #@staticmethod |
| def parse_bytes(header): |
| """ |
| Parse a Range header into (bytes, list_of_ranges). Note that the |
| ranges are *inclusive* (like in HTTP, not like in Python |
| typically). |
| |
| Will return None if the header is invalid |
| """ |
| if not header: |
| raise TypeError( |
| "The header must not be empty") |
| ranges = [] |
| last_end = 0 |
| try: |
| (units, range) = header.split("=", 1) |
| units = units.strip().lower() |
| for item in range.split(","): |
| if '-' not in item: |
| raise ValueError() |
| if item.startswith('-'): |
| # This is a range asking for a trailing chunk |
| if last_end < 0: |
| raise ValueError('too many end ranges') |
| begin = int(item) |
| end = None |
| last_end = -1 |
| else: |
| (begin, end) = item.split("-", 1) |
| begin = int(begin) |
| if begin < last_end or last_end < 0: |
| print begin, last_end |
| raise ValueError('begin<last_end, or last_end<0') |
| if not end.strip(): |
| end = None |
| else: |
| end = int(end) |
| if end is not None and begin > end: |
| raise ValueError('begin>end') |
| last_end = end |
| ranges.append((begin, end)) |
| except ValueError, e: |
| # In this case where the Range header is malformed, |
| # section 14.16 says to treat the request as if the |
| # Range header was not present. How do I log this? |
| print e |
| return None |
| return (units, ranges) |
| parse_bytes = staticmethod(parse_bytes) |
| |
| #@staticmethod |
| def serialize_bytes(units, ranges): |
| """ |
| Takes the output of parse_bytes and turns it into a header |
| """ |
| parts = [] |
| for begin, end in ranges: |
| if end is None: |
| if begin >= 0: |
| parts.append('%s-' % begin) |
| else: |
| parts.append(str(begin)) |
| else: |
| if begin < 0: |
| raise ValueError( |
| "(%r, %r) should have a non-negative first value" % (begin, end)) |
| if end < 0: |
| raise ValueError( |
| "(%r, %r) should have a non-negative second value" % (begin, end)) |
| parts.append('%s-%s' % (begin, end)) |
| return '%s=%s' % (units, ','.join(parts)) |
| serialize_bytes = staticmethod(serialize_bytes) |
| |
| #@staticmethod |
| def bytes_to_python_ranges(ranges, length=None): |
| """ |
| Converts the list-of-ranges from parse_bytes() to a Python-style |
| list of ranges (non-inclusive end points) |
| |
| In the list of ranges, the last item can be None to indicate that |
| it should go to the end of the file, and the first item can be |
| negative to indicate that it should start from an offset from the |
| end. If you give a length then this will not occur (negative |
| numbers and offsets will be resolved). |
| |
| If length is given, and any range is not value, then None is |
| returned. |
| """ |
| result = [] |
| for begin, end in ranges: |
| if begin < 0: |
| if length is None: |
| result.append((begin, None)) |
| continue |
| else: |
| begin = length - begin |
| end = length |
| if begin is None: |
| begin = 0 |
| if end is None and length is not None: |
| end = length |
| if length is not None and end is not None and end > length: |
| return None |
| if end is not None: |
| end -= 1 |
| result.append((begin, end)) |
| return result |
| bytes_to_python_ranges = staticmethod(bytes_to_python_ranges) |
| |
| #@staticmethod |
| def python_ranges_to_bytes(ranges): |
| """ |
| Converts a Python-style list of ranges to what serialize_bytes |
| expects. |
| |
| This is the inverse of bytes_to_python_ranges |
| """ |
| result = [] |
| for begin, end in ranges: |
| if end is None: |
| result.append((begin, None)) |
| else: |
| result.append((begin, end+1)) |
| return result |
| python_ranges_to_bytes = staticmethod(python_ranges_to_bytes) |
| |
| class ContentRange(object): |
| |
| """ |
| Represents the Content-Range header |
| |
| This header is ``start-stop/length``, where stop and length can be |
| ``*`` (represented as None in the attributes). |
| """ |
| |
| def __init__(self, start, stop, length): |
| assert start >= 0, "Bad start: %r" % start |
| assert stop is None or (stop >= 0 and stop >= start), ( |
| "Bad stop: %r" % stop) |
| self.start = start |
| self.stop = stop |
| self.length = length |
| |
| def __repr__(self): |
| return '<%s %s>' % ( |
| self.__class__.__name__, |
| self) |
| |
| def __str__(self): |
| if self.stop is None: |
| stop = '*' |
| else: |
| stop = self.stop + 1 |
| if self.length is None: |
| length = '*' |
| else: |
| length = self.length |
| return 'bytes %s-%s/%s' % (self.start, stop, length) |
| |
| def __iter__(self): |
| """ |
| Mostly so you can unpack this, like: |
| |
| start, stop, length = res.content_range |
| """ |
| return iter([self.start, self.stop, self.length]) |
| |
| #@classmethod |
| def parse(cls, value): |
| """ |
| Parse the header. May return None if it cannot parse. |
| """ |
| if value is None: |
| return None |
| value = value.strip() |
| if not value.startswith('bytes '): |
| # Unparseable |
| return None |
| value = value[len('bytes '):].strip() |
| if '/' not in value: |
| # Invalid, no length given |
| return None |
| range, length = value.split('/', 1) |
| if '-' not in range: |
| # Invalid, no range |
| return None |
| start, end = range.split('-', 1) |
| try: |
| start = int(start) |
| if end == '*': |
| end = None |
| else: |
| end = int(end) |
| if length == '*': |
| length = None |
| else: |
| length = int(length) |
| except ValueError: |
| # Parse problem |
| return None |
| if end is None: |
| return cls(start, None, length) |
| else: |
| return cls(start, end-1, length) |
| parse = classmethod(parse) |
| |
