[WIP] Relay Node/Connection support.

Author: jhgg

epoxy/contrib/__init__.py

@@ -0,0 +1,5 @@
+__author__ = 'jake'
+
+from .mixin import RelayMixin
+
+__all__ = ['RelayMixin']

epoxy/contrib/relay/__init__.py

@@ -0,0 +1,10 @@
+from graphql.core.type import GraphQLArgument, GraphQLInt, GraphQLString
+
+__author__ = 'jake'
+
+connection_args = {
+    'before': GraphQLArgument(GraphQLString),
+    'after': GraphQLArgument(GraphQLString),
+    'first': GraphQLArgument(GraphQLInt),
+    'last': GraphQLArgument(GraphQLInt),
+}

epoxy/contrib/relay/connections/__init__.py

@@ -0,0 +1,38 @@
+from ..utils import base64, unbase64
+
+
+class CursorFactory(object):
+    def __init__(self, prefix):
+        self.prefix = prefix
+        self.cursor_type = int
+        self.max_cursor_length = 10
+
+    def from_offset(self, offset):
+        """
+        Creates the cursor string from an offset.
+        """
+        return base64(self.prefix + str(offset))
+
+    def to_offset(self, cursor):
+        """
+        Rederives the offset from the cursor string.
+        """
+        try:
+            return self.cursor_type(unbase64(cursor)[len(self.prefix):len(self.prefix) + self.max_cursor_length])
+        except:
+            return None
+
+    def get_offset(self, cursor, default_offset=0):
+        """
+        Given an optional cursor and a default offset, returns the offset
+        to use; if the cursor contains a valid offset, that will be used,
+        otherwise it will be the default.
+        """
+        if cursor is None:
+            return default_offset
+
+        offset = self.to_offset(cursor)
+        try:
+            return self.cursor_type(offset)
+        except:
+            return default_offset

epoxy/contrib/relay/connections/cursor.py

@@ -0,0 +1,215 @@
+from bisect import bisect_left, bisect_right
+from .cursor import CursorFactory
+
+cursor = CursorFactory('sc:')
+
+
+class SortedCollection(object):
+    """Sequence sorted by a key function.
+
+    SortedCollection() is much easier to work with than using bisect() directly.
+    It supports key functions like those use in sorted(), min(), and max().
+    The result of the key function call is saved so that keys can be searched
+    efficiently.
+
+    Instead of returning an insertion-point which can be hard to interpret, the
+    five find-methods return a specific item in the sequence. They can scan for
+    exact matches, the last item less-than-or-equal to a key, or the first item
+    greater-than-or-equal to a key.
+
+    Once found, an item's ordinal position can be located with the index() method.
+    New items can be added with the insert() and insert_right() methods.
+    Old items can be deleted with the remove() method.
+
+    The usual sequence methods are provided to support indexing, slicing,
+    length lookup, clearing, copying, forward and reverse iteration, contains
+    checking, item counts, item removal, and a nice looking repr.
+
+    Finding and indexing are O(log n) operations while iteration and insertion
+    are O(n).  The initial sort is O(n log n).
+
+    The key function is stored in the 'key' attribute for easy introspection or
+    so that you can assign a new key function (triggering an automatic re-sort).
+
+    In short, the class was designed to handle all of the common use cases for
+    bisect but with a simpler API and support for key functions.
+
+    >>> from pprint import pprint
+    >>> from operator import itemgetter
+
+    >>> s = SortedCollection(key=itemgetter(2))
+    >>> for record in [
+    ...         ('roger', 'young', 30),
+    ...         ('angela', 'jones', 28),
+    ...         ('bill', 'smith', 22),
+    ...         ('david', 'thomas', 32)]:
+    ...     s.insert(record)
+
+    >>> pprint(list(s))         # show records sorted by age
+    [('bill', 'smith', 22),
+     ('angela', 'jones', 28),
+     ('roger', 'young', 30),
+     ('david', 'thomas', 32)]
+
+    >>> s.find_le(29)           # find oldest person aged 29 or younger
+    ('angela', 'jones', 28)
+    >>> s.find_lt(28)           # find oldest person under 28
+    ('bill', 'smith', 22)
+    >>> s.find_gt(28)           # find youngest person over 28
+    ('roger', 'young', 30)
+
+    >>> r = s.find_ge(32)       # find youngest person aged 32 or older
+    >>> s.index(r)              # get the index of their record
+    3
+    >>> s[3]                    # fetch the record at that index
+    ('david', 'thomas', 32)
+
+    >>> s.key = itemgetter(0)   # now sort by first name
+    >>> pprint(list(s))
+    [('angela', 'jones', 28),
+     ('bill', 'smith', 22),
+     ('david', 'thomas', 32),
+     ('roger', 'young', 30)]
+
+    """
+
+    def __init__(self, key=None):
+        self._given_key = key
+        key = (lambda x: x) if key is None else key
+        self._keys = []
+        self._items = []
+        self._key = key
+
+    def clear(self):
+        self._keys = []
+        self._items = []
+
+    def copy(self):
+        cls = self.__class__(key=self._key)
+        cls._items = self._items[:]
+        cls._keys = self._keys[:]
+
+    def __len__(self):
+        return len(self._items)
+
+    def __getitem__(self, i):
+        return self._items[i]
+
+    def __iter__(self):
+        return iter(self._items)
+
+    def __reversed__(self):
+        return reversed(self._items)
+
+    def __repr__(self):
+        return '%s(%r, key=%s)' % (
+            self.__class__.__name__,
+            self._items,
+            getattr(self._given_key, '__name__', repr(self._given_key))
+        )
+
+    def __reduce__(self):
+        return self.__class__, (self._items, self._given_key)
+
+    def __contains__(self, item):
+        k = self._key(item)
+        i = bisect_left(self._keys, k)
+        j = bisect_right(self._keys, k)
+        return item in self._items[i:j]
+
+    def index(self, item):
+        """Find the position of an item.  Raise ValueError if not found.'"""
+        k = self._key(item)
+        i = bisect_left(self._keys, k)
+        j = bisect_right(self._keys, k)
+        return self._items[i:j].index(item) + i
+
+    def count(self, item):
+        """Return number of occurrences of item'"""
+        k = self._key(item)
+        i = bisect_left(self._keys, k)
+        j = bisect_right(self._keys, k)
+        return self._items[i:j].count(item)
+
+    def insert(self, item):
+        """Insert a new item.  If equal keys are found, add to the left'"""
+        k = self._key(item)
+        i = bisect_left(self._keys, k)
+        if i != len(self) and self._keys[i] == k:
+            raise ValueError(u'An item with the same key {} already exists in this collection.'.format(k))
+
+        self._keys.insert(i, k)
+        self._items.insert(i, item)
+
+    def remove(self, item):
+        """Remove first occurrence of item.  Raise ValueError if not found'"""
+        i = self.index(item)
+        del self._keys[i]
+        del self._items[i]
+
+    def bisect_left(self, k):
+        return bisect_left(self._keys, k)
+
+    def bisect_right(self, k):
+        return bisect_right(self._keys, k)
+
+    @staticmethod
+    def empty_connection(relay, type_name):
+        Connection, Edge = relay.get_connection_and_edge_types(type_name)
+
+        return Connection(
+            edges=[],
+            page_info=relay.PageInfo(
+                start_cursor=None,
+                end_cursor=None,
+                has_previous_page=False,
+                has_next_page=False,
+            )
+        )
+
+    def get_connection(self, relay, type_name, args):
+        Connection, Edge = relay.get_connection_and_edge_types(type_name)
+        before = args.get('before')
+        after = args.get('after')
+        first = args.get('first')
+        last = args.get('last')
+
+        count = len(self)
+        if not count:
+            return self.empty_connection(relay, type_name)
+
+        begin_key = cursor.get_offset(after, None) or self._keys[0]
+        end_key = cursor.get_offset(before, None) or self._keys[-1]
+
+        begin = self.bisect_left(begin_key)
+        end = self.bisect_right(end_key)
+
+        if begin >= count or begin >= end:
+            return self.empty_connection(relay, type_name)
+
+        first_preslice_cursor = cursor.from_offset(self._keys[begin])
+        last_preslice_cursor = cursor.from_offset(self._keys[min(end, count) - 1])
+
+        if first is not None:
+            end = min(begin + first, end)
+        if last is not None:
+            begin = max(end - last, begin)
+
+        if begin >= count or begin >= end:
+            return self.empty_connection(relay, type_name)
+
+        sliced_data = self._items[begin:end]
+
+        edges = [Edge(node=node, cursor=cursor.from_offset(self._key(node))) for node in sliced_data]
+        first_edge = edges[0]
+        last_edge = edges[-1]
+
+        return Connection(
+            edges=edges,
+            page_info=relay.PageInfo(
+                start_cursor=first_edge.cursor,
+                end_cursor=last_edge.cursor,
+                has_previous_page=(first_edge.cursor != first_preslice_cursor),
+                has_next_page=(last_edge.cursor != last_preslice_cursor)
+            )
+        )

epoxy/contrib/relay/connections/sorted_collection.py

@@ -0,0 +1 @@
+__author__ = 'jake'

epoxy/contrib/relay/data_source/__init__.py

@@ -0,0 +1,27 @@
+from collections import defaultdict
+
+from operator import attrgetter
+from ..connections.sorted_collection import SortedCollection
+
+
+class InMemoryDataSource(object):
+    def __init__(self):
+        self.objects_by_type_and_id = defaultdict(dict)
+        self.objects_by_type = defaultdict(lambda: SortedCollection(key=attrgetter('id')))
+
+    def add(self, obj):
+        self.objects_by_type_and_id[obj.T][obj.id] = obj
+        self.objects_by_type[obj.T].insert(obj)
+
+    def fetch_node(self, object_type, id, resolve_info):
+        return self.objects_by_type_and_id[object_type].get(id)
+
+    def get_collection(self, object_type):
+        return self.objects_by_type[object_type()]
+
+    def make_connection_resolver(self, relay, object_type_thunk):
+        def resolver(obj, args, info):
+            object_type = relay.R[object_type_thunk]()
+            return self.objects_by_type[object_type].get_connection(relay, object_type.name, args)
+
+        return resolver

epoxy/contrib/relay/data_source/memory.py

@@ -0,0 +1,85 @@
+from graphql.core.type import GraphQLArgument
+from graphql.core.type.definition import GraphQLObjectType
+from .connections import connection_args
+from .utils import base64, unbase64
+
+
+class RelayMixin(object):
+    def __init__(self, registry):
+        self.R = registry
+        self._node_field = None
+        self._connections = {}
+        self.data_source = None
+
+    @property
+    def NodeField(self):
+        return self.R.Field(
+            self.R.Node,
+            description='Fetches an object given its ID',
+            args={
+                'id': GraphQLArgument(
+                    self.R.ID.NonNull(),
+                    description='The ID of an object'
+                )
+            },
+            resolver=lambda obj, args, info: self.fetch_node(args.get('id'), info)
+        )
+
+    def set_data_source(self, data_source):
+        self.data_source = data_source
+
+    def get_connection_and_edge_types(self, type_name):
+        return self._connections[type_name]
+
+    def register_types(self):
+        R = self.R
+
+        class Node(R.Interface):
+            id = R.ID.NonNull(description='The id of the object.')
+
+            resolve_id = self.resolve_node_id
+
+        class PageInfo(R.ObjectType):
+            has_next_page = R.Boolean.NonNull(description='When paginating forwards, are there more items?')
+            has_previous_page = R.Boolean.NonNull(description='When paginating backwards, are there more items?')
+            start_cursor = R.String(description='When paginating backwards, the cursor to continue.')
+            end_cursor = R.String(description='When paginating forwards, the cursor to continue.')
+
+        self.Node = Node
+        self.PageInfo = PageInfo
+
+    def fetch_node(self, id, info):
+        object_type_name, object_id = unbase64(id).split(':', 1)
+        object_type = self.R[object_type_name]()
+        assert isinstance(object_type, GraphQLObjectType)
+        return self.data_source.fetch_node(object_type, object_id, info)
+
+    def resolve_node_id(self, obj, args, info):
+        type = self.R.Node().resolve_type(obj, info)
+        return base64('%s:%s' % (type, obj.id))
+
+    def connection_definitions(self, name, object_type):
+        R = self.R
+
+        if name in self._connections:
+            return self._connections[name]
+
+        class Edge(R.ObjectType):
+            _name = '{}Edge'.format(name)
+            node = R[object_type](description='The item at the end of the edge')
+            cursor = R.String.NonNull(description='A cursor for use in pagination')
+
+        class Connection(R.ObjectType):
+            _name = '{}Connection'.format(name)
+
+            page_info = R.PageInfo.NonNull
+            edges = R[Edge].List
+
+        self._connections[name] = Connection, Edge
+        return Connection, Edge
+
+    def Connection(self, name, object_type, args=None, **kwargs):
+        args = args or {}
+        args.update(connection_args)
+        field = self.R.Field(self.connection_definitions(name, object_type)[0], args=args, **kwargs)
+        return field