add support for sqlalchemy 1.1

Author: dpep

graphene_sqlalchemy/converter.py

@@ -1,12 +1,10 @@
 from enum import EnumMeta
 
 from singledispatch import singledispatch
-from sqlalchemy import inspect, types
+from sqlalchemy import types
 from sqlalchemy.dialects import postgresql
-from sqlalchemy.ext.hybrid import hybrid_property
-from sqlalchemy.orm import (ColumnProperty, CompositeProperty,
-                            RelationshipProperty, interfaces, strategies)
-from sqlalchemy.orm.attributes import InstrumentedAttribute
+from sqlalchemy.orm import (ColumnProperty, RelationshipProperty, class_mapper,
+                            interfaces, strategies)
 
 from graphene import (ID, Boolean, Dynamic, Enum, Field, Float, Int, List,
                       String)
@@ -36,39 +34,35 @@ def is_column_nullable(column):
     return bool(getattr(column, "nullable", True))
 
 
-def convert_sqlalchemy_association_proxy(association_prop, obj_type, registry, connection_field_factory, batching, resolver, **field_kwargs):
-    model = association_prop.target_class
-
-    attr = getattr(model, association_prop.value_attr)
-    if isinstance(attr, InstrumentedAttribute):
-        attr = inspect(attr).property
-
+def convert_sqlalchemy_association_proxy(parent, assoc_prop, obj_type, registry,
+                                         connection_field_factory, batching, resolver, **field_kwargs):
     def dynamic_type():
+        prop = class_mapper(parent).attrs[assoc_prop.target_collection]
+        scalar = not prop.uselist
+        model = prop.mapper.class_
+        attr = class_mapper(model).attrs[assoc_prop.value_attr]
+
         if isinstance(attr, ColumnProperty):
             field = convert_sqlalchemy_column(
                 attr,
                 registry,
                 resolver,
                 **field_kwargs
             )
-            if not association_prop.scalar:
+            if not scalar:
                 # repackage as List
                 field.__dict__['_type'] = List(field.type)
-
             return field
         elif isinstance(attr, RelationshipProperty):
-            batching_ = field_kwargs.pop('batching', batching)
             return convert_sqlalchemy_relationship(
                 attr,
                 obj_type,
                 connection_field_factory,
-                batching_,
-                association_prop.value_attr,
+                field_kwargs.pop('batching', batching),
+                assoc_prop.value_attr,
                 **field_kwargs
-            # resolve Dynamic type
             ).get_type()
-
-        raise NotImplementedError(attr)
+        # else, not supported
 
     return Dynamic(dynamic_type)
 

graphene_sqlalchemy/tests/models.py

@@ -76,7 +76,7 @@ def hybrid_prop(self):
 
     composite_prop = composite(CompositeFullName, first_name, last_name, doc="Composite")
 
-    pet_names = association_proxy('pets', 'name')
+    headlines = association_proxy('articles', 'headline')
 
 
 class Article(Base):
@@ -85,7 +85,7 @@ class Article(Base):
     headline = Column(String(100))
     pub_date = Column(Date())
     reporter_id = Column(Integer(), ForeignKey("reporters.id"))
-    reporter_pets = association_proxy('reporter', 'pets')
+    recommended_reads = association_proxy('reporter', 'articles')
 
 
 class ReflectedEditor(type):

graphene_sqlalchemy/tests/test_converter.py

@@ -287,33 +287,38 @@ class Meta:
 
 
 def test_should_convert_association_proxy():
-    class P(SQLAlchemyObjectType):
+    class ReporterType(SQLAlchemyObjectType):
         class Meta:
-            model = Pet
+            model = Reporter
 
-    dynamic_field = convert_sqlalchemy_association_proxy(
-        Reporter.pet_names,
-        P,
+    class ArticleType(SQLAlchemyObjectType):
+        class Meta:
+            model = Article
+
+    field = convert_sqlalchemy_association_proxy(
+        Reporter,
+        Reporter.headlines,
+        ReporterType,
         get_global_registry(),
         default_connection_field_factory,
         True,
         mock_resolver,
     )
-    assert isinstance(dynamic_field, graphene.Dynamic)
-    graphene_type = dynamic_field.get_type()
-    assert isinstance(graphene_type, graphene.Field)
-    assert isinstance(graphene_type.type, graphene.List)
-    assert graphene_type.type.of_type == graphene.String
+    assert isinstance(field, graphene.Dynamic)
+    assert isinstance(field.get_type().type, graphene.List)
+    assert field.get_type().type.of_type == graphene.String
 
     dynamic_field = convert_sqlalchemy_association_proxy(
-        Article.reporter_pets,
-        P,
+        Article,
+        Article.recommended_reads,
+        ArticleType,
         get_global_registry(),
         default_connection_field_factory,
         True,
         mock_resolver,
     )
-    assert dynamic_field.get_type().type.of_type == P
+    assert isinstance(dynamic_field, graphene.Dynamic)
+    assert dynamic_field.get_type().type.of_type == ArticleType
 
 
 def test_should_postgresql_uuid_convert():

graphene_sqlalchemy/tests/test_query.py

@@ -57,6 +57,7 @@ def resolve_reporters(self, _info):
             columnProp
             hybridProp
             compositeProp
+            headlines
           }
           reporters {
             firstName
@@ -69,6 +70,7 @@ def resolve_reporters(self, _info):
             "hybridProp": "John",
             "columnProp": 2,
             "compositeProp": "John Doe",
+            "headlines": ['Hi!'],
         },
         "reporters": [{"firstName": "John"}, {"firstName": "Jane"}],
     }

graphene_sqlalchemy/tests/test_types.py

@@ -71,6 +71,11 @@ class Meta:
             model = Article
             interfaces = (Node,)
 
+    class PetType(SQLAlchemyObjectType):
+        class Meta:
+            model = Pet
+            interfaces = (Node,)
+
     assert list(ReporterType._meta.fields.keys()) == [
         # Columns
         "column_prop",  # SQLAlchemy retuns column properties first
@@ -84,7 +89,7 @@ class Meta:
         # Hybrid
         "hybrid_prop",
         # AssociationProxy
-        "pet_names",
+        "headlines",
         # Relationship
         "pets",
         "articles",
@@ -121,9 +126,14 @@ class Meta:
     assert favorite_article_field.type().description is None
 
     # assocation proxy
-    assoc_prop = ReporterType._meta.fields['pet_names']
-    assert isinstance(assoc_prop, Dynamic)
-    assert assoc_prop.type().type == List(String)
+    assoc_field = ReporterType._meta.fields['headlines']
+    assert isinstance(assoc_field, Dynamic)
+    assert isinstance(assoc_field.type().type, List)
+    assert assoc_field.type().type.of_type == String
+
+    assoc_field = ArticleType._meta.fields['recommended_reads']
+    assert isinstance(assoc_field, Dynamic)
+    assert assoc_field.type().type == ArticleType.connection
 
 
 def test_sqlalchemy_override_fields():
@@ -186,7 +196,7 @@ class Meta:
         # Then the automatic SQLAlchemy fields
         "id",
         "favorite_pet_kind",
-        "pet_names",
+        "headlines",
     ]
 
     first_name_field = ReporterType._meta.fields['first_name']
@@ -284,7 +294,7 @@ class Meta:
         "favorite_pet_kind",
         "composite_prop",
         "hybrid_prop",
-        "pet_names",
+        "headlines",
         "pets",
         "articles",
         "favorite_article",

graphene_sqlalchemy/types.py

@@ -13,7 +13,6 @@
 from graphene.types.utils import yank_fields_from_attrs
 from graphene.utils.orderedtype import OrderedType
 
-from .batching import get_batch_resolver
 from .converter import (convert_sqlalchemy_association_proxy,
                         convert_sqlalchemy_column,
                         convert_sqlalchemy_composite,
@@ -179,7 +178,8 @@ def construct_fields(
             field = convert_sqlalchemy_hybrid_method(attr, resolver, **orm_field.kwargs)
         elif isinstance(attr, AssociationProxy):
             field = convert_sqlalchemy_association_proxy(
-                attr.for_class(model),
+                model,
+                attr,
                 obj_type,
                 registry,
                 connection_field_factory,