Rework search result paging with a more generic base class.

Author: wagnerrp

tmdb3/pager.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#-----------------------
+# Name: pager.py    List-like structure designed for handling paged results
+# Python Library
+# Author: Raymond Wagner
+#-----------------------
+
+from collections import Sequence, Iterator
+
+class PagedIterator( Iterator ):
+    def __init__(self, parent):
+        self._parent = parent
+        self._index = -1
+        self._len = len(parent)
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        self._index += 1
+        if self._index == self._len:
+            raise StopIteration
+        return self._parent[self._index]
+
+class UnpagedData( object ):
+    def copy(self):
+        return self.__class__()
+
+    def __mul__(self, other):
+        return (self.copy() for a in range(other))
+
+    def __rmul__(self, other):
+        return (self.copy() for a in range(other))
+
+class PagedList( Sequence ):
+    """
+    List-like object, with support for automatically grabbing additional
+    pages from a data source.
+    """
+    _iter_class = None
+
+    def __iter__(self):
+        if self._iter_class is None:
+            self._iter_class = type(self.__class__.__name__ + 'Iterator',
+                                    (PagedIterator,), {})
+        return self._iter_class(self)
+
+    def __len__(self):
+        try:
+            return self._len
+        except:
+            return len(self._data)
+
+    def __init__(self, iterable, pagesize=20):
+        self._data = list(iterable)
+        self._pagesize = pagesize
+
+    def __getitem__(self, index):
+        if index >= len(self):
+            raise IndexError("list index outside range")
+        if (index >= len(self._data)) \
+                or isinstance(self._data[index], UnpagedData):
+            self._populatepage(index/self._pagesize + 1)
+        return self._data[index]
+
+    def __setitem__(self, index, value):
+        raise NotImplementedError
+
+    def __delitem__(self, index):
+        raise NotImplementedError
+
+    def __contains__(self, item):
+        raise NotImplementedError
+
+    def _populatepage(self, page):
+        pagestart = (page-1) * self._pagesize
+        if len(self._data) < pagestart:
+            self._data.extend(UnpagedData()*(pagestart-len(self._data)))
+        if len(self._data) == pagestart:
+            self._data.extend(self._getpage(page))
+        else:
+            for data in self._getpage(page):
+                self._data[pagestart] = data
+                pagestart += 1
+
+    def _getpage(self, page):
+        raise NotImplementedError("PagedList._getpage() must be provided "+\
+                                  "by subclass")
+
+class PagedRequest( PagedList ):
+    """
+    Derived PageList that provides a list-like object with automatic paging
+    intended for use with search requests.
+    """
+    def __init__(self, request, handler=None):
+        self._request = request
+        if handler: self._handler = handler
+        super(PagedRequest, self).__init__(self._getpage(1), 20)
+
+    def _getpage(self, page):
+        req = self._request.new(page=page)
+        res = req.readJSON()
+        self._len = res['total_results']
+        for item in res['results']:
+            yield self._handler(item)
+

tmdb3/tmdb_api.py

@@ -33,7 +33,8 @@
 # 0.3.4 Re-enable search paging
 
 from request import set_key, Request
-from util import PagedList, Datapoint, Datalist, Datadict, Element
+from util import Datapoint, Datalist, Datadict, Element
+from pager import PagedRequest
 from tmdb_exceptions import *
 
 import json
@@ -50,47 +51,31 @@ def _populate(self):
 Configuration = Configuration()
 
 def searchMovie(query, language='en', adult=False):
-    return MovieSearchResults(
+    return MovieSearchResult(
                     Request('search/movie', query=query, include_adult=adult),
                     language=language)
 
-class MovieSearchResults( PagedList ):
+class MovieSearchResult( PagedRequest ):
     """Stores a list of search matches."""
-    def _process(self, data):
-        for item in data['results']:
-            yield Movie(raw=item, language=self.language)
-
-    def _getpage(self, page):
-        self.request = self.request.new(page=page)
-        return list(self._process(self.request.readJSON()))
-
     def __init__(self, request, language=None):
-        self.language=language
         if language:
-            self.request = request.new(language=language)
-        res = self.request.readJSON()
-        super(MovieSearchResults, self).__init__(res, res['total_results'], 20)
-
+            super(MovieSearchResult, self).__init__(
+                                request.new(language=language),
+                                lambda x: Movie(raw=x, language=language))
+        else:
+            super(MovieSearchResult, self).__init__(res,
+                                lambda x: Movie(raw=x))
+    
     def __repr__(self):
-        return u"<Search Results: {0}>".format(self.request._kwargs['query'])
+        return u"<Search Results: {0}>".format(self._request._kwargs['query'])
 
 def searchPerson(query):
-    return PeopleSearchResults(Request('search/person', query=query))
-
-class PeopleSearchResults( PagedList ):
-    @staticmethod
-    def _process(data):
-        for item in data['results']:
-            yield Person(raw=item)
-
-    def _getpage(self, page):
-        self.request = self.request.new(page=page)
-        return list(self._process(self.request.readJSON()))
+    return PeopleSearchResult(Request('search/person', query=query))
 
+class PeopleSearchResult( PagedRequest ):
+    """Stores a list of search matches."""
     def __init__(self, request):
-        self.request = request
-        res = self.request.readJSON()
-        super(PeopleSearchResults, self).__init__(res, res['total_results'], 20)
+        super(PeopleSearchResults, self).__init__(res)
 
     def __repr__(self):
         return u"<Search Results: {0}>".format(self.request._kwargs['query'])

tmdb3/util.py

@@ -8,42 +8,6 @@
 
 from copy import copy
 
-class PagedList( list ):
-    """
-    List-like object, with support for automatically grabbing additional
-    pages from a data source.
-    """
-    def __init__(self, iterable, count, perpage=20):
-        self._perpage = perpage
-        if count:
-            super(PagedList, self).__init__(self._process(iterable))
-            super(PagedList, self).extend([None]*(count-len(self)))
-        else:
-            super(PagedList, self).__init__()
-
-    def _getpage(self, page):
-        raise NotImplementedError("PagedList._getpage() must be provided "+\
-                                  "by subclass")
-
-    def _populateindex(self, index):
-        self._populatepage(int(index/self._perpage)+1)
-
-    def _populatepage(self, page):
-        offset = (page-1)*self._perpage
-        for i,data in enumerate(self._getpage(page)):
-            super(PagedList, self).__setitem__(offset+i, data)
-
-    def __getitem__(self, index):
-        item = super(PagedList, self).__getitem__(index)
-        if item is None:
-            self._populateindex(index)
-        item = super(PagedList, self).__getitem__(index)
-        return item
-
-    def __iter__(self):
-        for i in range(len(self)):
-            yield self[i]
-
 class Poller( object ):
     """
     Wrapper for an optional callable to populate an Element derived class