Merge branch 'master' into master

Author: syrusakbary

.travis.yml

@@ -6,19 +6,19 @@ python:
 - 3.5
 - pypy
 before_install:
-  - |
-      if [ "$TRAVIS_PYTHON_VERSION" = "pypy" ]; then
-        export PYENV_ROOT="$HOME/.pyenv"
-        if [ -f "$PYENV_ROOT/bin/pyenv" ]; then
-          cd "$PYENV_ROOT" && git pull
-        else
-          rm -rf "$PYENV_ROOT" && git clone --depth 1 https://github.com/yyuu/pyenv.git "$PYENV_ROOT"
-        fi
-        export PYPY_VERSION="4.0.1"
-        "$PYENV_ROOT/bin/pyenv" install "pypy-$PYPY_VERSION"
-        virtualenv --python="$PYENV_ROOT/versions/pypy-$PYPY_VERSION/bin/python" "$HOME/virtualenvs/pypy-$PYPY_VERSION"
-        source "$HOME/virtualenvs/pypy-$PYPY_VERSION/bin/activate"
-      fi
+- |
+  if [ "$TRAVIS_PYTHON_VERSION" = "pypy" ]; then
+    export PYENV_ROOT="$HOME/.pyenv"
+    if [ -f "$PYENV_ROOT/bin/pyenv" ]; then
+      cd "$PYENV_ROOT" && git pull
+    else
+      rm -rf "$PYENV_ROOT" && git clone --depth 1 https://github.com/yyuu/pyenv.git "$PYENV_ROOT"
+    fi
+    export PYPY_VERSION="4.0.1"
+    "$PYENV_ROOT/bin/pyenv" install "pypy-$PYPY_VERSION"
+    virtualenv --python="$PYENV_ROOT/versions/pypy-$PYPY_VERSION/bin/python" "$HOME/virtualenvs/pypy-$PYPY_VERSION"
+    source "$HOME/virtualenvs/pypy-$PYPY_VERSION/bin/activate"
+  fi
 install:
 - |
   if [ "$TEST_TYPE" = build ]; then
@@ -50,3 +50,10 @@ matrix:
   include:
   - python: '2.7'
     env: TEST_TYPE=lint
+deploy:
+  provider: pypi
+  user: syrusakbary
+  on:
+    tags: true
+  password:
+    secure: q0ey31cWljGB30l43aEd1KIPuAHRutzmsd2lBb/2zvD79ReBrzvCdFAkH2xcyo4Volk3aazQQTNUIurnTuvBxmtqja0e+gUaO5LdOcokVdOGyLABXh7qhd2kdvbTDWgSwA4EWneLGXn/SjXSe0f3pCcrwc6WDcLAHxtffMvO9gulpYQtUoOqXfMipMOkRD9iDWTJBsSo3trL70X1FHOVr6Yqi0mfkX2Y/imxn6wlTWRz28Ru94xrj27OmUnCv7qcG0taO8LNlUCquNFAr2sZ+l+U/GkQrrM1y+ehPz3pmI0cCCd7SX/7+EG9ViZ07BZ31nk4pgnqjmj3nFwqnCE/4IApGnduqtrMDF63C9TnB1TU8oJmbbUCu4ODwRpBPZMnwzaHsLnrpdrB89/98NtTfujdrh3U5bVB+t33yxrXVh+FjgLYj9PVeDixpFDn6V/Xcnv4BbRMNOhXIQT7a7/5b99RiXBjCk6KRu+Jdu5DZ+3G4Nbr4oim3kZFPUHa555qbzTlwAfkrQxKv3C3OdVJR7eGc9ADsbHyEJbdPNAh/T+xblXTXLS3hPYDvgM+WEGy3CytBDG3JVcXm25ZP96EDWjweJ7MyfylubhuKj/iR1Y1wiHeIsYq9CqRrFQUWL8gFJBfmgjs96xRXXXnvyLtKUKpKw3wFg5cR/6FnLeYZ8k=

README.md

@@ -22,7 +22,7 @@ Here is a simple SQLAlchemy model:
 
 ```python
 from sqlalchemy import Column, Integer, String
-from sqlalchemy.orm import backref, relationship
+from sqlalchemy.orm import relationship
 
 from sqlalchemy.ext.declarative import declarative_base
 

docs/tutorial.rst

@@ -95,8 +95,6 @@ Create ``flask_sqlalchemy/schema.py`` and type the following:
     from graphene_sqlalchemy import SQLAlchemyObjectType, SQLAlchemyConnectionField
     from models import db_session, Department as DepartmentModel, Employee as EmployeeModel
 
-    schema = graphene.Schema()
-
 
     class Department(SQLAlchemyObjectType):
         class Meta:
@@ -114,7 +112,7 @@ Create ``flask_sqlalchemy/schema.py`` and type the following:
         node = relay.Node.Field()
         all_employees = SQLAlchemyConnectionField(Employee)
 
-    schema.query = Query
+    schema = graphene.Schema(query=Query)
 
 Creating GraphQL and GraphiQL views in Flask
 --------------------------------------------

examples/flask_sqlalchemy/README.md

@@ -13,8 +13,8 @@ whole Graphene repository:
 
 ```bash
 # Get the example project code
-git clone https://github.com/graphql-python/graphene.git
-cd graphene/examples/flask_sqlalchemy
+git clone https://github.com/graphql-python/graphene-sqlalchemy.git
+cd graphene-sqlalchemy/examples/flask_sqlalchemy
 ```
 
 It is good idea (but not required) to create a virtual environment
@@ -46,5 +46,5 @@ Now the following command will setup the database, and start the server:
 
 
 Now head on over to
-[http://127.0.0.1:5000/graphiql](http://127.0.0.1:5000/graphiql)
+[http://127.0.0.1:5000/graphql](http://127.0.0.1:5000/graphql)
 and run some queries!

examples/flask_sqlalchemy/app.py

@@ -1,3 +1,5 @@
+#!/usr/bin/env python
+
 from flask import Flask
 
 from database import db_session, init_db

graphene_sqlalchemy/converter.py

@@ -11,7 +11,7 @@
 from .fields import SQLAlchemyConnectionField
 
 try:
-    from sqlalchemy_utils import ChoiceType, JSONType, ScalarListType
+    from sqlalchemy_utils import ChoiceType, JSONType, ScalarListType, TSVectorType
 except ImportError:
     class ChoiceType(object):
         pass
@@ -23,6 +23,14 @@ class JSONType(object):
         pass
 
 
+def get_column_doc(column):
+    return getattr(column, 'doc', None)
+
+
+def is_column_nullable(column):
+    return bool(getattr(column, 'nullable', True))
+
+
 def convert_sqlalchemy_relationship(relationship, registry):
     direction = relationship.direction
     model = relationship.mapper.entity
@@ -40,7 +48,10 @@ def dynamic_type():
             return Field(List(_type))
 
     return Dynamic(dynamic_type)
-
+    
+def convert_sqlalchemy_hybrid_method(hybrid_item):
+     return String(description=getattr(hybrid_item, '__doc__', None),
+                   required=False)
 
 def convert_sqlalchemy_composite(composite, registry):
     converter = registry.get_converter_for_composite(composite.composite_class)
@@ -66,6 +77,7 @@ def inner(fn):
         registry.register_composite_converter(cls, fn)
     return inner
 
+
 convert_sqlalchemy_composite.register = _register_composite_class
 
 
@@ -80,7 +92,6 @@ def convert_sqlalchemy_type(type, column, registry=None):
 
 
 @convert_sqlalchemy_type.register(types.Date)
-@convert_sqlalchemy_type.register(types.DateTime)
 @convert_sqlalchemy_type.register(types.Time)
 @convert_sqlalchemy_type.register(types.String)
 @convert_sqlalchemy_type.register(types.Text)
@@ -89,56 +100,66 @@ def convert_sqlalchemy_type(type, column, registry=None):
 @convert_sqlalchemy_type.register(types.Enum)
 @convert_sqlalchemy_type.register(postgresql.ENUM)
 @convert_sqlalchemy_type.register(postgresql.UUID)
+@convert_sqlalchemy_type.register(TSVectorType)
 def convert_column_to_string(type, column, registry=None):
-    return String(description=getattr(column, 'doc', None),
-                  required=not(getattr(column, 'nullable', True)))
+    return String(description=get_column_doc(column),
+                  required=not(is_column_nullable(column)))
+
+
+@convert_sqlalchemy_type.register(types.DateTime)
+def convert_column_to_datetime(type, column, registry=None):
+    from graphene.types.datetime import DateTime
+    return DateTime(description=get_column_doc(column),
+                    required=not(is_column_nullable(column)))
 
 
 @convert_sqlalchemy_type.register(types.SmallInteger)
-@convert_sqlalchemy_type.register(types.BigInteger)
 @convert_sqlalchemy_type.register(types.Integer)
 def convert_column_to_int_or_id(type, column, registry=None):
     if column.primary_key:
-        return ID(description=column.doc, required=not(column.nullable))
+        return ID(description=get_column_doc(column), required=not (is_column_nullable(column)))
     else:
-        return Int(description=column.doc, required=not(column.nullable))
+        return Int(description=get_column_doc(column),
+                   required=not (is_column_nullable(column)))
 
 
 @convert_sqlalchemy_type.register(types.Boolean)
 def convert_column_to_boolean(type, column, registry=None):
-    return Boolean(description=column.doc, required=not(column.nullable))
+    return Boolean(description=get_column_doc(column), required=not(is_column_nullable(column)))
 
 
 @convert_sqlalchemy_type.register(types.Float)
 @convert_sqlalchemy_type.register(types.Numeric)
+@convert_sqlalchemy_type.register(types.BigInteger)
 def convert_column_to_float(type, column, registry=None):
-    return Float(description=column.doc, required=not(column.nullable))
+    return Float(description=get_column_doc(column), required=not(is_column_nullable(column)))
 
 
 @convert_sqlalchemy_type.register(ChoiceType)
 def convert_column_to_enum(type, column, registry=None):
     name = '{}_{}'.format(column.table.name, column.name).upper()
-    return Enum(name, type.choices, description=column.doc)
+    return Enum(name, type.choices, description=get_column_doc(column))
 
 
 @convert_sqlalchemy_type.register(ScalarListType)
 def convert_scalar_list_to_list(type, column, registry=None):
-    return List(String, description=column.doc)
+    return List(String, description=get_column_doc(column))
 
 
 @convert_sqlalchemy_type.register(postgresql.ARRAY)
-def convert_postgres_array_to_list(type, column, registry=None):
+def convert_postgres_array_to_list(_type, column, registry=None):
     graphene_type = convert_sqlalchemy_type(column.type.item_type, column)
-    return List(graphene_type, description=column.doc, required=not(column.nullable))
+    inner_type = type(graphene_type)
+    return List(inner_type, description=get_column_doc(column), required=not(is_column_nullable(column)))
 
 
 @convert_sqlalchemy_type.register(postgresql.HSTORE)
 @convert_sqlalchemy_type.register(postgresql.JSON)
 @convert_sqlalchemy_type.register(postgresql.JSONB)
 def convert_json_to_string(type, column, registry=None):
-    return JSONString(description=column.doc, required=not(column.nullable))
+    return JSONString(description=get_column_doc(column), required=not(is_column_nullable(column)))
 
 
 @convert_sqlalchemy_type.register(JSONType)
 def convert_json_type_to_string(type, column, registry=None):
-    return JSONString(description=column.doc, required=not(column.nullable))
+    return JSONString(description=get_column_doc(column), required=not(is_column_nullable(column)))

graphene_sqlalchemy/fields.py

@@ -39,6 +39,7 @@ def connection_resolver(cls, resolver, connection, model, root, args, context, i
             edge_type=connection.Edge,
         )
         connection.iterable = iterable
+        connection.length = _len
         return connection
 
     def get_resolver(self, parent_resolver):

graphene_sqlalchemy/tests/test_converter.py

@@ -8,6 +8,7 @@
 
 import graphene
 from graphene.relay import Node
+from graphene.types.datetime import DateTime
 from graphene.types.json import JSONString
 
 from ..converter import (convert_sqlalchemy_column,
@@ -52,7 +53,7 @@ def test_should_date_convert_string():
 
 
 def test_should_datetime_convert_string():
-    assert_column_conversion(types.DateTime(), graphene.String)
+    assert_column_conversion(types.DateTime(), DateTime)
 
 
 def test_should_time_convert_string():
@@ -84,7 +85,7 @@ def test_should_small_integer_convert_int():
 
 
 def test_should_big_integer_convert_int():
-    assert_column_conversion(types.BigInteger(), graphene.Int)
+    assert_column_conversion(types.BigInteger(), graphene.Float)
 
 
 def test_should_integer_convert_int():
@@ -113,6 +114,11 @@ def test_should_label_convert_string():
     assert isinstance(graphene_type, graphene.String)
 
 
+def test_should_label_convert_int():
+    label = Label('int_label_test', case([], else_="foo"), type_=types.Integer())
+    graphene_type = convert_sqlalchemy_column(label)
+    assert isinstance(graphene_type, graphene.Int)
+
 def test_should_choice_convert_enum():
     TYPES = [
         (u'es', u'Spanish'),

graphene_sqlalchemy/tests/test_query.py

@@ -5,6 +5,7 @@
 import graphene
 from graphene.relay import Node
 
+from ..registry import reset_global_registry
 from ..fields import SQLAlchemyConnectionField
 from ..types import SQLAlchemyObjectType
 from .models import Article, Base, Editor, Reporter
@@ -14,6 +15,7 @@
 
 @pytest.yield_fixture(scope='function')
 def session():
+    reset_global_registry()
     connection = db.engine.connect()
     transaction = connection.begin()
     Base.metadata.create_all(connection)

graphene_sqlalchemy/types.py

@@ -2,6 +2,7 @@
 
 import six
 from sqlalchemy.inspection import inspect as sqlalchemyinspect
+from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm.exc import NoResultFound
 
 from graphene import Field, ObjectType
@@ -13,7 +14,8 @@
 
 from .converter import (convert_sqlalchemy_column,
                         convert_sqlalchemy_composite,
-                        convert_sqlalchemy_relationship)
+                        convert_sqlalchemy_relationship,
+                        convert_sqlalchemy_hybrid_method)
 from .registry import Registry, get_global_registry
 from .utils import get_query, is_mapped
 
@@ -47,6 +49,24 @@ def construct_fields(options):
         converted_composite = convert_sqlalchemy_composite(composite, options.registry)
         fields[name] = converted_composite
 
+    for hybrid_item in inspected_model.all_orm_descriptors:
+
+        if type(hybrid_item) == hybrid_property:
+            name = hybrid_item.__name__
+
+            is_not_in_only = only_fields and name not in only_fields
+            is_already_created = name in options.fields
+            is_excluded = name in exclude_fields or is_already_created
+
+            if is_not_in_only or is_excluded:
+            # We skip this field if we specify only_fields and is not
+            # in there. Or when we excldue this field in exclude_fields
+
+                continue
+            converted_hybrid_property = convert_sqlalchemy_hybrid_method(
+            hybrid_item)
+            fields[name] = converted_hybrid_property
+
     # Get all the columns for the relationships on the model
     for relationship in inspected_model.relationships:
         is_not_in_only = only_fields and relationship.key not in only_fields
@@ -141,5 +161,6 @@ def get_node(cls, id, context, info):
     def resolve_id(self, args, context, info):
         graphene_type = info.parent_type.graphene_type
         if is_node(graphene_type):
-            return self.__mapper__.primary_key_from_instance(self)[0]
+            keys = self.__mapper__.primary_key_from_instance(self)
+            return tuple(keys) if len(keys) > 1 else keys[0]
         return getattr(self, graphene_type._meta.id, None)