add support for sqlalchemy 1.1

Author: dpep

graphene_sqlalchemy/converter.py

@@ -5,7 +5,8 @@
 from sqlalchemy.dialects import postgresql
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import (ColumnProperty, CompositeProperty,
-                            RelationshipProperty, interfaces, strategies)
+                            RelationshipProperty, class_mapper, interfaces,
+                            strategies)
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 
 from graphene import (ID, Boolean, Dynamic, Enum, Field, Float, Int, List,
@@ -36,39 +37,36 @@ 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(
+            field = 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()
+        else:
+            raise NotImplementedError(attr)
 
-        raise NotImplementedError(attr)
+        return field
 
     return Dynamic(dynamic_type)
 

graphene_sqlalchemy/tests/test_converter.py

@@ -291,28 +291,29 @@ class P(SQLAlchemyObjectType):
         class Meta:
             model = Pet
 
-    dynamic_field = convert_sqlalchemy_association_proxy(
+    field = convert_sqlalchemy_association_proxy(
+        Reporter,
         Reporter.pet_names,
         P,
         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,
         Article.reporter_pets,
         P,
         get_global_registry(),
         default_connection_field_factory,
         True,
         mock_resolver,
     )
+    assert isinstance(dynamic_field, graphene.Dynamic)
     assert dynamic_field.get_type().type.of_type == P
 
 

graphene_sqlalchemy/tests/test_types.py

@@ -121,9 +121,10 @@ 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['pet_names']
+    assert isinstance(assoc_field, Dynamic)
+    assert isinstance(assoc_field.type().type, List)
+    assert assoc_field.type().type.of_type == String
 
 
 def test_sqlalchemy_override_fields():

graphene_sqlalchemy/types.py

@@ -179,7 +179,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,