release: 3.4.3

* Do not raise AttributeError when parsing non-string UUIDs

When a user sends a dictionary or other object as a UUID variable like `{[123]}`, previously graphene crashed with an `AttributeError`, like this:

```
(…)
  File "…/lib/python3.12/site-packages/graphql/utils/is_valid_value.py", line 78, in is_valid_value
    parse_result = type.parse_value(value)
                   ^^^^^^^^^^^^^^^^^^^^^^^
  File "…/lib/python3.12/site-packages/graphene/types/uuid.py", line 33, in parse_value
    return _UUID(value)
           ^^^^^^^^^^^^
  File "/usr/lib/python3.12/uuid.py", line 175, in __init__
    hex = hex.replace('urn:', '').replace('uuid:', '')
          ^^^^^^^^^^^
AttributeError: 'dict' object has no attribute 'replace'
```

But an `AttributeError` makes it seem like this is the server's fault, when it's obviously the client's.

Report a proper GraphQLError.

* fix: adjust exception message structure

---------

Co-authored-by: Erik Wrede <erikwrede@users.noreply.github.com>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: "\U0001F41B bug"
+assignees: ''
+
+---
+
+**Note: for support questions, please use stackoverflow**. This repository's issues are reserved for feature requests and bug reports.
+
+* **What is the current behavior?**
+
+
+
+* **If the current behavior is a bug, please provide the steps to reproduce and if possible a minimal demo of the problem** via
+a github repo, https://repl.it or similar.
+
+
+
+* **What is the expected behavior?**
+
+
+
+* **What is the motivation / use case for changing the behavior?**
+
+
+
+* **Please tell us about your environment:**
+
+  - Version:
+  - Platform:
+
+* **Other information** (e.g. detailed explanation, stacktraces, related issues, suggestions how to fix, links for us to have context, eg. stackoverflow)

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: "✨ enhancement"
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/stale.yml

@@ -1,17 +1,24 @@
 # Number of days of inactivity before an issue becomes stale
-daysUntilStale: 90
+daysUntilStale: false
 # Number of days of inactivity before a stale issue is closed
-daysUntilClose: 14
+daysUntilClose: false
 # Issues with these labels will never be considered stale
 exemptLabels:
   - pinned
   - security
+  - 🐛 bug
+  - 📖 documentation
+  - 🙋 help wanted
+  - ✨ enhancement
+  - good first issue
+  - work in progress
 # Label to use when marking an issue as stale
 staleLabel: wontfix
 # Comment to post when marking an issue as stale. Set to `false` to disable
-markComment: >
+markComment: false
-  This issue has been automatically marked as stale because it has not had
+# markComment: >
-  recent activity. It will be closed if no further activity occurs. Thank you
+  # This issue has been automatically marked as stale because it has not had
-  for your contributions.
+  # recent activity. It will be closed if no further activity occurs. Thank you
+  # for your contributions.
 # Comment to post when closing a stale issue. Set to `false` to disable
 closeComment: false

.github/workflows/build.yaml

@@ -0,0 +1,21 @@
+name: 📦 Build
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build twine
+    - name: Building package
+      run: python3 -m build
+    - name: Check package with Twine
+      run: twine check dist/*

.github/workflows/deploy.yml

@@ -0,0 +1,26 @@
+name: 🚀 Deploy to PyPI
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.10"
+    - name: Build wheel and source tarball
+      run: |
+        pip install wheel
+        python setup.py sdist bdist_wheel
+    - name: Publish a Python distribution to PyPI
+      uses: pypa/gh-action-pypi-publish@v1.1.0
+      with:
+        user: __token__
+        password: ${{ secrets.pypi_password }}

.github/workflows/lint.yml

@@ -0,0 +1,26 @@
+name: 💅 Lint
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install tox
+    - name: Run lint
+      run: tox
+      env:
+        TOXENV: pre-commit
+    - name: Run mypy
+      run: tox
+      env:
+        TOXENV: mypy

.github/workflows/tests.yml

@@ -0,0 +1,64 @@
+name: 📄 Tests
+on:
+  push:
+    branches:
+      - master
+      - '*.x'
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+      - '*.rst'
+  pull_request:
+    branches:
+      - master
+      - '*.x'
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+      - '*.rst'
+jobs:
+  tests:
+    # runs the test suite
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {name: '3.13', python: '3.13', os: ubuntu-latest, tox: py313}
+          - {name: '3.12', python: '3.12', os: ubuntu-latest, tox: py312}
+          - {name: '3.11', python: '3.11', os: ubuntu-latest, tox: py311}
+          - {name: '3.10', python: '3.10', os: ubuntu-latest, tox: py310}
+          - {name: '3.9', python: '3.9', os: ubuntu-latest, tox: py39}
+          - {name: '3.8', python: '3.8', os: ubuntu-latest, tox: py38}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: update pip
+        run: |
+          python -m pip install --upgrade pip
+          pip install --upgrade setuptools wheel
+
+      - name: get pip cache dir
+        id: pip-cache
+        run: echo "dir=$(pip cache dir)" >> $GITHUB_OUTPUT
+      - name: cache pip dependencies
+        uses: actions/cache@v3
+        with:
+          path: ${{ steps.pip-cache.outputs.dir }}
+          key: pip|${{ runner.os }}|${{ matrix.python }}|${{ hashFiles('setup.py') }}
+      - run: pip install tox
+      - run: tox -e ${{ matrix.tox }}
+      - name: Upload coverage.xml
+        if: ${{ matrix.python == '3.10' }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: graphene-coverage
+          path: coverage.xml
+          if-no-files-found: error
+      - name: Upload coverage.xml to codecov
+        if: ${{ matrix.python == '3.10' }}
+        uses: codecov/codecov-action@v4

.gitignore

@@ -90,3 +90,4 @@ venv/
 *.sqlite3
 .vscode
 .mypy_cache
+.ruff_cache

.isort.cfg

@@ -1,2 +0,0 @@
-[settings]
-known_third_party = aniso8601,graphql,graphql_relay,promise,pytest,pytz,pyutils,setuptools,six,snapshottest,sphinx_graphene_theme

.pre-commit-config.yaml

@@ -1,6 +1,9 @@
+default_language_version:
+  python: python3.10
+
 repos:
--   repo: git://github.com/pre-commit/pre-commit-hooks
+-   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v2.1.0
+    rev: v4.3.0
     hooks:
     -   id: check-merge-conflict
     -   id: check-json
@@ -14,15 +17,13 @@ repos:
     -   id: trailing-whitespace
         exclude: README.md
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v1.12.0
+    rev: v2.37.3
     hooks:
     -   id: pyupgrade
--   repo: https://github.com/ambv/black
+-   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 19.3b0
+    # Ruff version.
+    rev: v0.5.0
     hooks:
-    - id: black
+        - id: ruff
-      language_version: python3
+        - id: ruff-format
--   repo: https://github.com/PyCQA/flake8
+          args: [ --check ]
-    rev: 3.7.8
-    hooks:
-    -   id: flake8

.travis.yml

@@ -1,42 +0,0 @@
-language: python
-dist: xenial
-
-python:
-  - "3.6"
-  - "3.7"
-  - "3.8"
-
-install:
-  - pip install tox tox-travis
-script: tox
-after_success:
-  - pip install coveralls
-  - coveralls
-cache:
-  directories:
-    - $HOME/.cache/pip
-    - $HOME/.cache/pre-commit
-
-stages:
-  - test
-  - name: deploy
-    if: tag IS present
-
-jobs:
-  fast_finish: true
-  include:
-    - env: TOXENV=pre-commit
-      python: 3.7
-    - env: TOXENV=mypy
-      python: 3.7
-    - stage: deploy
-      python: 3.7
-      after_success: true
-      deploy:
-        provider: pypi
-        user: syrusakbary
-        on:
-          tags: true
-        password:
-          secure: LHOp9DvYR+70vj4YVY8+JRNCKUOfYZREEUY3+4lMUpY7Zy5QwDfgEMXG64ybREH9dFldpUqVXRj53eeU3spfudSfh8NHkgqW7qihez2AhSnRc4dK6ooNfB+kLcSoJ4nUFGxdYImABc4V1hJvflGaUkTwDNYVxJF938bPaO797IvSbuI86llwqkvuK2Vegv9q/fy9sVGaF9VZIs4JgXwR5AyDR7FBArl+S84vWww4vTFD33hoE88VR4QvFY3/71BwRtQrnCMm7AOm31P9u29yi3bpzQpiOR2rHsgrsYdm597QzFKVxYwsmf9uAx2bpbSPy2WibunLePIvOFwm8xcfwnz4/J4ONBc5PSFmUytTWpzEnxb0bfUNLuYloIS24V6OZ8BfAhiYZ1AwySeJCQDM4Vk1V8IF6trTtyx5EW/uV9jsHCZ3LFsAD7UnFRTosIgN3SAK3ZWCEk5oF2IvjecsolEfkRXB3q9EjMkkuXRUeFDH2lWJLgNE27BzY6myvZVzPmfwZUsPBlPD/6w+WLSp97Rjgr9zS3T1d4ddqFM4ZYu04f2i7a/UUQqG+itzzuX5DWLPvzuNt37JB45mB9IsvxPyXZ6SkAcLl48NGyKok1f3vQnvphkfkl4lni29woKhaau8xlsuEDrcwOoeAsVcZXiItg+l+z2SlIwM0A06EvQ=
-        distributions: "sdist bdist_wheel"

CODEOWNERS

@@ -1,3 +0,0 @@
-* @ekampf @dan98765 @projectcheshire @jkimbo
-/docs/ @dvndrsn @phalt @changeling
-/examples/ @dvndrsn @phalt @changeling

Makefile

@@ -7,8 +7,9 @@ help:
 install-dev:
 	pip install -e ".[dev]"
 
+.PHONY: test ## Run tests
 test:
-	py.test graphene examples tests_asyncio
+	py.test graphene examples
 
 .PHONY: docs ## Generate docs
 docs: install-dev
@@ -20,8 +21,8 @@ docs-live: install-dev
 
 .PHONY: format
 format:
-	black graphene examples setup.py tests_asyncio
+	black graphene examples setup.py
 
 .PHONY: lint
 lint:
-	flake8 graphene examples setup.py tests_asyncio
+	flake8 graphene examples setup.py

README.md

@@ -1,14 +1,8 @@
-# ![Graphene Logo](http://graphene-python.org/favicon.png) [Graphene](http://graphene-python.org) [![Build Status](https://travis-ci.org/graphql-python/graphene.svg?branch=master)](https://travis-ci.org/graphql-python/graphene) [![PyPI version](https://badge.fury.io/py/graphene.svg)](https://badge.fury.io/py/graphene) [![Coverage Status](https://coveralls.io/repos/graphql-python/graphene/badge.svg?branch=master&service=github)](https://coveralls.io/github/graphql-python/graphene?branch=master)
+# ![Graphene Logo](http://graphene-python.org/favicon.png) [Graphene](http://graphene-python.org)  [![PyPI version](https://badge.fury.io/py/graphene.svg)](https://badge.fury.io/py/graphene) [![Coverage Status](https://coveralls.io/repos/graphql-python/graphene/badge.svg?branch=master&service=github)](https://coveralls.io/github/graphql-python/graphene?branch=master) [![](https://dcbadge.vercel.app/api/server/T6Gp6NFYHe?style=flat)](https://discord.gg/T6Gp6NFYHe)
 
-[💬 Join the community on Slack](https://join.slack.com/t/graphenetools/shared_invite/enQtOTE2MDQ1NTg4MDM1LTA4Nzk0MGU0NGEwNzUxZGNjNDQ4ZjAwNDJjMjY0OGE1ZDgxZTg4YjM2ZTc4MjE2ZTAzZjE2ZThhZTQzZTkyMmM)
+[💬 Join the community on Discord](https://discord.gg/T6Gp6NFYHe)
 
-**We are looking for contributors**! Please check the [ROADMAP](https://github.com/graphql-python/graphene/blob/master/ROADMAP.md) to see how you can help ❤️
+**We are looking for contributors**! Please check the current issues to see how you can help ❤️
-
----
-
-**The below readme is the documentation for the `dev` (prerelease) version of Graphene. To view the documentation for the latest stable Graphene version go to the [v2 docs](https://docs.graphene-python.org/en/stable/)**
-
----
 
 ## Introduction
 
@@ -16,7 +10,7 @@
 
 - **Easy to use:** Graphene helps you use GraphQL in Python without effort.
 - **Relay:** Graphene has builtin support for Relay.
-- **Data agnostic:** Graphene supports any kind of data source: SQL (Django, SQLAlchemy), NoSQL, custom Python objects, etc.
+- **Data agnostic:** Graphene supports any kind of data source: SQL (Django, SQLAlchemy), Mongo, custom Python objects, etc.
   We believe that by providing a complete API you could plug Graphene anywhere your data lives and make your data available
   through GraphQL.
 
@@ -26,18 +20,19 @@ Graphene has multiple integrations with different frameworks:
 
 | integration       | Package                                                                                 |
 | ----------------- | --------------------------------------------------------------------------------------- |
-| Django            | [graphene-django](https://github.com/graphql-python/graphene-django/)                   |
 | SQLAlchemy        | [graphene-sqlalchemy](https://github.com/graphql-python/graphene-sqlalchemy/)           |
-| Google App Engine | [graphene-gae](https://github.com/graphql-python/graphene-gae/)                         |
+| Mongo             | [graphene-mongo](https://github.com/graphql-python/graphene-mongo/)                     |
+| Apollo Federation | [graphene-federation](https://github.com/graphql-python/graphene-federation/)           |
+| Django            | [graphene-django](https://github.com/graphql-python/graphene-django/)                   |
 
 Also, Graphene is fully compatible with the GraphQL spec, working seamlessly with all GraphQL clients, such as [Relay](https://github.com/facebook/relay), [Apollo](https://github.com/apollographql/apollo-client) and [gql](https://github.com/graphql-python/gql).
 
 ## Installation
 
-For instaling graphene, just run this command in your shell
+To install `graphene`, just run this command in your shell
 
 ```bash
-pip install "graphene>=2.0"
+pip install "graphene>=3.1"
 ```
 
 ## Examples
@@ -45,6 +40,8 @@ pip install "graphene>=2.0"
 Here is one example for you to get started:
 
 ```python
+import graphene
+
 class Query(graphene.ObjectType):
     hello = graphene.String(description='A typical hello world')
 
@@ -88,18 +85,24 @@ pip install -e ".[test]"
 Well-written tests and maintaining good test coverage is important to this project. While developing, run new and existing tests with:
 
 ```sh
-py.test graphene/relay/tests/test_node.py # Single file
+pytest graphene/relay/tests/test_node.py # Single file
-py.test graphene/relay # All tests in directory
+pytest graphene/relay # All tests in directory
 ```
 
 Add the `-s` flag if you have introduced breakpoints into the code for debugging.
 Add the `-v` ("verbose") flag to get more detailed test output. For even more detailed output, use `-vv`.
 Check out the [pytest documentation](https://docs.pytest.org/en/latest/) for more options and test running controls.
 
+Regularly ensure your `pre-commit` hooks are up to date and enabled:
+
+```sh
+pre-commit install
+```
+
 You can also run the benchmarks with:
 
 ```sh
-py.test graphene --benchmark-only
+pytest graphene --benchmark-only
 ```
 
 Graphene supports several versions of Python. To make sure that changes do not break compatibility with any of those versions, we use `tox` to create virtualenvs for each Python version and run tests with that version. To run against all Python versions defined in the `tox.ini` config file, just run:
@@ -111,10 +114,10 @@ tox
 If you wish to run against a specific version defined in the `tox.ini` file:
 
 ```sh
-tox -e py36
+tox -e py39
 ```
 
-Tox can only use whatever versions of Python are installed on your system. When you create a pull request, Travis will also be running the same tests and report the results, so there is no need for potential contributors to try to install every single version of Python on their own system ahead of time. We appreciate opening issues and pull requests to make graphene even more stable & useful!
+Tox can only use whatever versions of Python are installed on your system. When you create a pull request, GitHub Actions pipelines will also be running the same tests and report the results, so there is no need for potential contributors to try to install every single version of Python on their own system ahead of time. We appreciate opening issues and pull requests to make graphene even more stable & useful!
 
 ### Building Documentation
 

README.rst

@@ -1,177 +0,0 @@
-**We are looking for contributors**! Please check the
-`ROADMAP <https://github.com/graphql-python/graphene/blob/master/ROADMAP.md>`__
-to see how you can help ❤️
-
---------------
-
-|Graphene Logo| `Graphene <http://graphene-python.org>`__ |Build Status| |PyPI version| |Coverage Status|
-=========================================================================================================
-
-
-Introduction
-------------
-
-`Graphene <http://graphene-python.org>`__ is a Python library for
-building GraphQL schemas/types fast and easily.
-
--  **Easy to use:** Graphene helps you use GraphQL in Python without
-   effort.
--  **Relay:** Graphene has builtin support for Relay.
--  **Data agnostic:** Graphene supports any kind of data source: SQL
-   (Django, SQLAlchemy), NoSQL, custom Python objects, etc. We believe
-   that by providing a complete API you could plug Graphene anywhere
-   your data lives and make your data available through GraphQL.
-
-Integrations
-------------
-
-Graphene has multiple integrations with different frameworks:
-
-+---------------------+----------------------------------------------------------------------------------------------+
-| integration         | Package                                                                                      |
-+=====================+==============================================================================================+
-| Django              | `graphene-django <https://github.com/graphql-python/graphene-django/>`__                     |
-+---------------------+----------------------------------------------------------------------------------------------+
-| SQLAlchemy          | `graphene-sqlalchemy <https://github.com/graphql-python/graphene-sqlalchemy/>`__             |
-+---------------------+----------------------------------------------------------------------------------------------+
-| Google App Engine   | `graphene-gae <https://github.com/graphql-python/graphene-gae/>`__                           |
-+---------------------+----------------------------------------------------------------------------------------------+
-| Peewee              | *In progress* (`Tracking Issue <https://github.com/graphql-python/graphene/issues/289>`__)   |
-+---------------------+----------------------------------------------------------------------------------------------+
-
-Also, Graphene is fully compatible with the GraphQL spec, working
-seamlessly with all GraphQL clients, such as
-`Relay <https://github.com/facebook/relay>`__,
-`Apollo <https://github.com/apollographql/apollo-client>`__ and
-`gql <https://github.com/graphql-python/gql>`__.
-
-Installation
-------------
-
-For instaling graphene, just run this command in your shell
-
-.. code:: bash
-
-    pip install "graphene>=2.0"
-
-2.0 Upgrade Guide
------------------
-
-Please read `UPGRADE-v2.0.md </UPGRADE-v2.0.md>`__ to learn how to
-upgrade.
-
-Examples
---------
-
-Here is one example for you to get started:
-
-.. code:: python
-
-    class Query(graphene.ObjectType):
-        hello = graphene.String(description='A typical hello world')
-
-        def resolve_hello(self, info):
-            return 'World'
-
-    schema = graphene.Schema(query=Query)
-
-Then Querying ``graphene.Schema`` is as simple as:
-
-.. code:: python
-
-    query = '''
-        query SayHello {
-          hello
-        }
-    '''
-    result = schema.execute(query)
-
-If you want to learn even more, you can also check the following
-`examples <examples/>`__:
-
--  **Basic Schema**: `Starwars example <examples/starwars>`__
--  **Relay Schema**: `Starwars Relay
-   example <examples/starwars_relay>`__
-
-Documentation
--------------
-
-Documentation and links to additional resources are available at
-https://docs.graphene-python.org/en/latest/
-
-Contributing
-------------
-
-After cloning this repo, create a
-`virtualenv <https://virtualenv.pypa.io/en/stable/>`__ and ensure
-dependencies are installed by running:
-
-.. code:: sh
-
-    virtualenv venv
-    source venv/bin/activate
-    pip install -e ".[test]"
-
-Well-written tests and maintaining good test coverage is important to
-this project. While developing, run new and existing tests with:
-
-.. code:: sh
-
-    py.test graphene/relay/tests/test_node.py # Single file
-    py.test graphene/relay # All tests in directory
-
-Add the ``-s`` flag if you have introduced breakpoints into the code for
-debugging. Add the ``-v`` ("verbose") flag to get more detailed test
-output. For even more detailed output, use ``-vv``. Check out the
-`pytest documentation <https://docs.pytest.org/en/latest/>`__ for more
-options and test running controls.
-
-You can also run the benchmarks with:
-
-.. code:: sh
-
-    py.test graphene --benchmark-only
-
-Graphene supports several versions of Python. To make sure that changes
-do not break compatibility with any of those versions, we use ``tox`` to
-create virtualenvs for each Python version and run tests with that
-version. To run against all Python versions defined in the ``tox.ini``
-config file, just run:
-
-.. code:: sh
-
-    tox
-
-If you wish to run against a specific version defined in the ``tox.ini``
-file:
-
-.. code:: sh
-
-    tox -e py36
-
-Tox can only use whatever versions of Python are installed on your
-system. When you create a pull request, Travis will also be running the
-same tests and report the results, so there is no need for potential
-contributors to try to install every single version of Python on their
-own system ahead of time. We appreciate opening issues and pull requests
-to make graphene even more stable & useful!
-
-Building Documentation
-~~~~~~~~~~~~~~~~~~~~~~
-
-The documentation is generated using the excellent
-`Sphinx <http://www.sphinx-doc.org/>`__ and a custom theme.
-
-An HTML version of the documentation is produced by running:
-
-.. code:: sh
-
-    make docs
-
-.. |Graphene Logo| image:: http://graphene-python.org/favicon.png
-.. |Build Status| image:: https://travis-ci.org/graphql-python/graphene.svg?branch=master
-   :target: https://travis-ci.org/graphql-python/graphene
-.. |PyPI version| image:: https://badge.fury.io/py/graphene.svg
-   :target: https://badge.fury.io/py/graphene
-.. |Coverage Status| image:: https://coveralls.io/repos/graphql-python/graphene/badge.svg?branch=master&service=github
-   :target: https://coveralls.io/github/graphql-python/graphene?branch=master

ROADMAP.md

@@ -1,54 +0,0 @@
-# GraphQL Python Roadmap
-
-In order to move Graphene and the GraphQL Python ecosystem forward it's essential to be clear with the community on next steps, so we can move uniformly.
-
-_👋 If you have more ideas on how to move the Graphene ecosystem forward, don't hesistate to [open a PR](https://github.com/graphql-python/graphene/edit/master/ROADMAP.md)_
-
-
-## Now
-- [ ] Continue to support v2.x with security releases
-- [ ] Last major/feature release is cut and graphene-* libraries should pin to that version number
-
-## Next
-New features will only be developed on version 3 of ecosystem libraries.
-
-### [Core-Next](https://github.com/graphql-python/graphql-core-next)
-Targeted as v3 of [graphql-core](https://pypi.org/project/graphql-core/), Python 3 only
-
-### Graphene
-- [ ] Integrate with the core-next API and resolve all breaking changes
-- [ ] GraphQL types from type annotations - [See issue](https://github.com/graphql-python/graphene/issues/729)
-- [ ] Add support for coroutines in Connection, Mutation (abstracting out Promise requirement) - [See PR](https://github.com/graphql-python/graphene/pull/824)
-
-### Graphene-*
-- [ ] Integrate with the graphene core-next API and resolve all breaking changes
-
-### *-graphql
-- [ ] Integrate with the graphql core-next API and resolve all breaking changes
-
-## Ongoing Initiatives
-- [ ] Improve documentation, especially for new users to the library
-- [ ] Recipes for “quick start” that people can ideally use/run
-
-
-## Dependent Libraries
-| Repo                                                                         | Release Manager | CODEOWNERS | Pinned     | next/master created | Labels Standardized |
-| ---------------------------------------------------------------------------- | --------------- | ---------- | ---------- | ------------------- | ------------------- |
-| [graphene](https://github.com/graphql-python/graphene)                       | ekampf          | ✅          |            | ✅                   |                     |
-| [graphql-core](https://github.com/graphql-python/graphql-core)               | Cito            | ✅          | N/A        | N/A                 |                     |
-| [graphql-core-next](https://github.com/graphql-python/graphql-core-next)     | Cito            | ✅          | N/A        | N/A                 |                     |
-| [graphql-server-core](https://github.com/graphql-python/graphql-server-core) | Cito            |            | ✅          | ✅                   |                     |
-| [gql](https://github.com/graphql-python/gql)                                 | ekampf          |            |            |                     |                     |
-| [gql-next](https://github.com/graphql-python/gql-next)                       | ekampf          |            | N/A        | N/A                 |                     |
-| ...[aiohttp](https://github.com/graphql-python/aiohttp-graphql)              |                 |            |            |                     |                     |
-| ...[django](https://github.com/graphql-python/graphene-django)               | mvanlonden      |            | ✅          | ✅                   |                     |
-| ...[sanic](https://github.com/graphql-python/sanic-graphql)                  | ekampf          |            |            |                     |                     |
-| ...[flask](https://github.com/graphql-python/flask-graphql)                  |                 |            |            |                     |                     |
-| ...[webob](https://github.com/graphql-python/webob-graphql)                  |                 |            |            |                     |                     |
-| ...[tornado](https://github.com/graphql-python/graphene-tornado)             | ewhauser        |            | PR created | ✅                   |                     |
-| ...[ws](https://github.com/graphql-python/graphql-ws)                        | Cito/dfee       |            | ✅          | ✅                   |                     |
-| ...[gae](https://github.com/graphql-python/graphene-gae)                     | ekampf          |            | PR created | ✅                   |                     |
-| ...[sqlalchemy](https://github.com/graphql-python/graphene-sqlalchemy)       | jnak/Nabell     | ✅          | ✅          | ✅                   |                     |
-| ...[mongo](https://github.com/graphql-python/graphene-mongo)                 |                 |            | ✅          | ✅                   |                     |
-| ...[relay-py](https://github.com/graphql-python/graphql-relay-py)            | Cito            |            |            |                     |                     |
-| ...[wsgi](https://github.com/moritzmhmk/wsgi-graphql)                        |                 |            |            |                     |                     |

SECURITY.md

@@ -0,0 +1,15 @@
+# Security Policy
+
+## Supported Versions
+
+Support for security issues is currently provided for Graphene 3.0 and above. Support on earlier versions cannot be guaranteed by the maintainers of this library, but community PRs may be accepted in critical cases.
+The preferred mitigation strategy is via an upgrade to Graphene 3.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 3.x     | :white_check_mark: |
+| <3.x    | :x:                |
+
+## Reporting a Vulnerability
+
+Please use responsible disclosure by contacting a core maintainer via Discord or E-Mail.

UPGRADE-v1.0.md

@@ -153,7 +153,7 @@ class Query(ObjectType):
 ```
 
 Also, if you wanted to create an `ObjectType` that implements `Node`, you have to do it
-explicity.
+explicitly.
 
 ## Django
 

UPGRADE-v2.0.md

@@ -123,7 +123,7 @@ def resolve_my_field(root, info, my_arg):
     return ...
 ```
 
-**PS.: Take care with receiving args like `my_arg` as above. This doesn't work for optional (non-required) arguments as stantard `Connection`'s arguments (first, before, after, before).**
+**PS.: Take care with receiving args like `my_arg` as above. This doesn't work for optional (non-required) arguments as standard `Connection`'s arguments (first, last, after, before).**
 You may need something like this:
 
 ```python
@@ -377,10 +377,7 @@ class Base(ObjectType):
     id = ID()
 
     def resolve_id(root, info):
-        return "{type}_{id}".format(
+        return f"{root.__class__.__name__}_{root.id}"
-            type=root.__class__.__name__,
-            id=root.id
-        )
 ```
 
 ### UUID Scalar

bin/autolinter

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-# Install the required scripts with
-# pip install autoflake autopep8 isort
-autoflake ./examples/ ./graphene/ -r --remove-unused-variables --remove-all-unused-imports --in-place
-autopep8 ./examples/ ./graphene/ -r --in-place --experimental --aggressive --max-line-length 120
-isort -rc ./examples/ ./graphene/

docs/api/index.rst

@@ -20,6 +20,8 @@ Object types
 .. autoclass:: graphene.Mutation
     :members:
 
+.. _fields-mounted-types:
+
 Fields (Mounted Types)
 ----------------------
 
@@ -62,6 +64,8 @@ Graphene Scalars
 
 .. autoclass:: graphene.JSONString()
 
+.. autoclass:: graphene.Base64()
+
 Enum
 ----
 
@@ -88,7 +92,7 @@ Execution Metadata
 
 .. autoclass:: graphene.Context
 
-.. autoclass:: graphql.execution.base.ExecutionResult
+.. autoclass:: graphql.ExecutionResult
 
 .. Relay
 .. -----

docs/conf.py

@@ -1,4 +1,5 @@
 import os
+import sys
 
 import sphinx_graphene_theme
 
@@ -22,8 +23,6 @@ on_rtd = os.environ.get("READTHEDOCS", None) == "True"
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 #
-import os
-import sys
 
 sys.path.insert(0, os.path.abspath(".."))
 
@@ -64,25 +63,25 @@ source_suffix = ".rst"
 master_doc = "index"
 
 # General information about the project.
-project = u"Graphene"
+project = "Graphene"
-copyright = u"Graphene 2016"
+copyright = "Graphene 2016"
-author = u"Syrus Akbary"
+author = "Syrus Akbary"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-version = u"1.0"
+version = "1.0"
 # The full version, including alpha/beta/rc tags.
-release = u"1.0"
+release = "1.0"
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = None
+# language = None
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
@@ -278,7 +277,7 @@ latex_elements = {
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, "Graphene.tex", u"Graphene Documentation", u"Syrus Akbary", "manual")
+    (master_doc, "Graphene.tex", "Graphene Documentation", "Syrus Akbary", "manual")
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -318,7 +317,7 @@ latex_documents = [
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [(master_doc, "graphene", u"Graphene Documentation", [author], 1)]
+man_pages = [(master_doc, "graphene", "Graphene Documentation", [author], 1)]
 
 # If true, show URL addresses after external links.
 #
@@ -334,7 +333,7 @@ texinfo_documents = [
     (
         master_doc,
         "Graphene",
-        u"Graphene Documentation",
+        "Graphene Documentation",
         author,
         "Graphene",
         "One line description of project.",
@@ -456,5 +455,4 @@ intersphinx_mapping = {
         "http://docs.graphene-python.org/projects/sqlalchemy/en/latest/",
         None,
     ),
-    "graphene_gae": ("http://docs.graphene-python.org/projects/gae/en/latest/", None),
 }

docs/execution/dataloader.rst

@@ -4,7 +4,7 @@ Dataloader
 DataLoader is a generic utility to be used as part of your application's
 data fetching layer to provide a simplified and consistent API over
 various remote data sources such as databases or web services via batching
-and caching.
+and caching. It is provided by a separate package `aiodataloader <https://pypi.org/project/aiodataloader/>`.
 
 
 Batching
@@ -15,32 +15,31 @@ Create loaders by providing a batch loading function.
 
 .. code:: python
 
-    from promise import Promise
+    from aiodataloader import DataLoader
-    from promise.dataloader import DataLoader
 
     class UserLoader(DataLoader):
-        def batch_load_fn(self, keys):
+        async def batch_load_fn(self, keys):
-            # Here we return a promise that will result on the
+            # Here we call a function to return a user for each key in keys
-            # corresponding user for each key in keys
+            return [get_user(id=key) for key in keys]
-            return Promise.resolve([get_user(id=key) for key in keys])
 
 
-A batch loading function accepts a list of keys, and returns a ``Promise``
+A batch loading async function accepts a list of keys, and returns a list of ``values``.
-which resolves to a list of ``values``.
 
-Then load individual values from the loader. ``DataLoader`` will coalesce all
+
-individual loads which occur within a single frame of execution (executed once
+``DataLoader`` will coalesce all individual loads which occur within a
-the wrapping promise is resolved) and then call your batch function with all
+single frame of execution (executed once the wrapping event loop is resolved)
-requested keys.
+and then call your batch function with all requested keys.
 
 
 .. code:: python
 
     user_loader = UserLoader()
 
-    user_loader.load(1).then(lambda user: user_loader.load(user.best_friend_id))
+    user1 = await user_loader.load(1)
+    user1_best_friend = await user_loader.load(user1.best_friend_id)
 
-    user_loader.load(2).then(lambda user: user_loader.load(user.best_friend_id))
+    user2 = await user_loader.load(2)
+    user2_best_friend = await user_loader.load(user2.best_friend_id)
 
 
 A naive application may have issued *four* round-trips to a backend for the
@@ -54,9 +53,9 @@ make sure that you then order the query result for the results to match the keys
 .. code:: python
 
    class UserLoader(DataLoader):
-       def batch_load_fn(self, keys):
+       async def batch_load_fn(self, keys):
            users = {user.id: user for user in User.objects.filter(id__in=keys)}
-           return Promise.resolve([users.get(user_id) for user_id in keys])
+           return [users.get(user_id) for user_id in keys]
 
 
 ``DataLoader`` allows you to decouple unrelated parts of your application without
@@ -96,7 +95,7 @@ Consider the following GraphQL request:
     }
 
 
-Naively, if ``me``, ``bestFriend`` and ``friends`` each need to request the backend,
+If ``me``, ``bestFriend`` and ``friends`` each need to send a request to the backend,
 there could be at most 13 database requests!
 
 
@@ -111,8 +110,8 @@ leaner code and at most 4 database requests, and possibly fewer if there are cac
         best_friend = graphene.Field(lambda: User)
         friends = graphene.List(lambda: User)
 
-        def resolve_best_friend(root, info):
+        async def resolve_best_friend(root, info):
-            return user_loader.load(root.best_friend_id)
+            return await user_loader.load(root.best_friend_id)
 
-        def resolve_friends(root, info):
+        async def resolve_friends(root, info):
-            return user_loader.load_many(root.friend_ids)
+            return await user_loader.load_many(root.friend_ids)

docs/execution/execute.rst

@@ -3,7 +3,6 @@
 Executing a query
 =================
 
-
 For executing a query against a schema, you can directly call the ``execute`` method on it.
 
 
@@ -86,7 +85,7 @@ Value used for :ref:`ResolverParamParent` in root queries and mutations can be o
             return {'id': root.id, 'firstName': root.name}
 
     schema = Schema(Query)
-    user_root = User(id=12, name='bob'}
+    user_root = User(id=12, name='bob')
     result = schema.execute(
         '''
         query getUser {
@@ -111,7 +110,7 @@ If there are multiple operations defined in a query string, ``operation_name`` s
     from graphene import ObjectType, Field, Schema
 
     class Query(ObjectType):
-        me = Field(User)
+        user = Field(User)
 
         def resolve_user(root, info):
             return get_user_by_id(12)

docs/execution/fileuploading.rst

@@ -4,5 +4,5 @@ File uploading
 File uploading is not part of the official GraphQL spec yet and is not natively
 implemented in Graphene.
 
-If your server needs to support file uploading then you can use the libary: `graphene-file-upload <https://github.com/lmcgartland/graphene-file-upload>`_ which enhances Graphene to add file
+If your server needs to support file uploading then you can use the library: `graphene-file-upload <https://github.com/lmcgartland/graphene-file-upload>`_ which enhances Graphene to add file
 uploads and conforms to the unoffical GraphQL `multipart request spec <https://github.com/jaydenseric/graphql-multipart-request-spec>`_.

docs/execution/index.rst

@@ -9,3 +9,5 @@ Execution
    middleware
    dataloader
    fileuploading
+   subscriptions
+   queryvalidation

docs/execution/middleware.rst

@@ -41,12 +41,14 @@ And then execute it with:
 
     result = schema.execute('THE QUERY', middleware=[AuthorizationMiddleware()])
 
+If the ``middleware`` argument includes multiple middlewares,
+these middlewares will be executed bottom-up, i.e. from last to first.
 
 Functional example
 ------------------
 
 Middleware can also be defined as a function. Here we define a middleware that
-logs the time it takes to resolve each field
+logs the time it takes to resolve each field:
 
 .. code:: python
 
@@ -55,12 +57,9 @@ logs the time it takes to resolve each field
     def timing_middleware(next, root, info, **args):
         start = timer()
         return_value = next(root, info, **args)
-        duration = timer() - start
+        duration = round((timer() - start) * 1000, 2)
-        logger.debug("{parent_type}.{field_name}: {duration} ms".format(
+        parent_type_name = root._meta.name if root and hasattr(root, '_meta') else ''
-            parent_type=root._meta.name if root and hasattr(root, '_meta') else '',
+        logger.debug(f"{parent_type_name}.{info.field_name}: {duration} ms")
-            field_name=info.field_name,
-            duration=round(duration * 1000, 2)
-        ))
         return return_value
 
 

docs/execution/queryvalidation.rst

@@ -0,0 +1,123 @@
+Query Validation
+================
+GraphQL uses query validators to check if Query AST is valid and can be executed. Every GraphQL server implements
+standard query validators. For example, there is an validator that tests if queried field exists on queried type, that
+makes query fail with "Cannot query field on type" error if it doesn't.
+
+To help with common use cases, graphene provides a few validation rules out of the box.
+
+
+Depth limit Validator
+---------------------
+The depth limit validator helps to prevent execution of malicious
+queries. It takes in the following arguments.
+
+- ``max_depth`` is the maximum allowed depth for any operation in a GraphQL document.
+- ``ignore`` Stops recursive depth checking based on a field name. Either a string or regexp to match the name, or a function that returns a boolean
+- ``callback`` Called each time validation runs. Receives an Object which is a map of the depths for each operation.
+
+Usage
+-----
+
+Here is how you would implement depth-limiting on your schema.
+
+.. code:: python
+
+    from graphql import validate, parse
+    from graphene import ObjectType, Schema, String
+    from graphene.validation import depth_limit_validator
+
+
+    class MyQuery(ObjectType):
+        name = String(required=True)
+
+
+    schema = Schema(query=MyQuery)
+
+    # queries which have a depth more than 20
+    # will not be executed.
+
+    validation_errors = validate(
+        schema=schema.graphql_schema,
+        document_ast=parse('THE QUERY'),
+        rules=(
+            depth_limit_validator(
+                max_depth=20
+            ),
+        )
+    )
+
+
+Disable Introspection
+---------------------
+the disable introspection validation rule ensures that your schema cannot be introspected.
+This is a useful security measure in production environments.
+
+Usage
+-----
+
+Here is how you would disable introspection for your schema.
+
+.. code:: python
+
+    from graphql import validate, parse
+    from graphene import ObjectType, Schema, String
+    from graphene.validation import DisableIntrospection
+
+
+    class MyQuery(ObjectType):
+        name = String(required=True)
+
+
+    schema = Schema(query=MyQuery)
+
+    # introspection queries will not be executed.
+
+    validation_errors = validate(
+        schema=schema.graphql_schema,
+        document_ast=parse('THE QUERY'),
+        rules=(
+            DisableIntrospection,
+        )
+    )
+
+
+Implementing custom validators
+------------------------------
+All custom query validators should extend the `ValidationRule <https://github.com/graphql-python/graphql-core/blob/v3.0.5/src/graphql/validation/rules/__init__.py#L37>`_
+base class importable from the graphql.validation.rules module. Query validators are visitor classes. They are
+instantiated at the time of query validation with one required argument (context: ASTValidationContext). In order to
+perform validation, your validator class should define one or more of enter_* and leave_* methods. For possible
+enter/leave items as well as details on function documentation, please see contents of the visitor module. To make
+validation fail, you should call validator's report_error method with the instance of GraphQLError describing failure
+reason. Here is an example query validator that visits field definitions in GraphQL query and fails query validation
+if any of those fields are blacklisted:
+
+.. code:: python
+
+    from graphql import GraphQLError
+    from graphql.language import FieldNode
+    from graphql.validation import ValidationRule
+
+
+    my_blacklist = (
+        "disallowed_field",
+    )
+
+
+    def is_blacklisted_field(field_name: str):
+        return field_name.lower() in my_blacklist
+
+
+    class BlackListRule(ValidationRule):
+        def enter_field(self, node: FieldNode, *_args):
+            field_name = node.name.value
+            if not is_blacklisted_field(field_name):
+                return
+
+            self.report_error(
+                GraphQLError(
+                    f"Cannot query '{field_name}': field is blacklisted.", node,
+                )
+            )
+

docs/execution/subscriptions.rst

@@ -0,0 +1,40 @@
+.. _SchemaSubscription:
+
+Subscriptions
+=============
+
+To create a subscription, you can directly call the ``subscribe`` method on the
+schema. This method is async and must be awaited.
+
+.. code:: python
+
+    import asyncio
+    from datetime import datetime
+    from graphene import ObjectType, String, Schema, Field
+
+    # Every schema requires a query.
+    class Query(ObjectType):
+        hello = String()
+
+        def resolve_hello(root, info):
+            return "Hello, world!"
+
+    class Subscription(ObjectType):
+        time_of_day = String()
+
+        async def subscribe_time_of_day(root, info):
+            while True:
+                yield datetime.now().isoformat()
+                await asyncio.sleep(1)
+
+    schema = Schema(query=Query, subscription=Subscription)
+
+    async def main(schema):
+        subscription = 'subscription { timeOfDay }'
+        result = await schema.subscribe(subscription)
+        async for item in result:
+            print(item.data['timeOfDay'])
+
+    asyncio.run(main(schema))
+
+The ``result`` is an async iterator which yields items in the same manner as a query.

docs/index.rst

@@ -1,12 +1,6 @@
 Graphene
 ========
 
-------------
-
-The documentation below is for the ``dev`` (prerelease) version of Graphene. To view the documentation for the latest stable Graphene version go to the `v2 docs <https://docs.graphene-python.org/en/stable/>`_.
-
-------------
-
 Contents:
 
 .. toctree::
@@ -27,7 +21,6 @@ Integrations
 * `Graphene-Django <http://docs.graphene-python.org/projects/django/en/latest/>`_ (`source <https://github.com/graphql-python/graphene-django/>`_)
 * Flask-Graphql (`source <https://github.com/graphql-python/flask-graphql>`_)
 * `Graphene-SQLAlchemy <http://docs.graphene-python.org/projects/sqlalchemy/en/latest/>`_ (`source <https://github.com/graphql-python/graphene-sqlalchemy/>`_)
-* `Graphene-GAE <http://docs.graphene-python.org/projects/gae/en/latest/>`_ (`source <https://github.com/graphql-python/graphene-gae/>`_)
 * `Graphene-Mongo <http://graphene-mongo.readthedocs.io/en/latest/>`_ (`source <https://github.com/graphql-python/graphene-mongo>`_)
 * `Starlette <https://www.starlette.io/graphql/>`_ (`source <https://github.com/encode/starlette>`_)
-* `FastAPI <https://fastapi.tiangolo.com/tutorial/graphql/>`_ (`source <https://github.com/tiangolo/fastapi>`_)
+* `FastAPI <https://fastapi.tiangolo.com/advanced/graphql/>`_ (`source <https://github.com/tiangolo/fastapi>`_)

docs/quickstart.rst

@@ -28,7 +28,7 @@ Compare Graphene's *code-first* approach to building a GraphQL API with *schema-
 
 .. _Apollo Server: https://www.apollographql.com/docs/apollo-server/
 
-.. _Ariadne: https://ariadne.readthedocs.io
+.. _Ariadne: https://ariadnegraphql.org/
 
 Graphene is fully featured with integrations for the most popular web frameworks and ORMs. Graphene produces schemas that are fully compliant with the GraphQL spec and provides tools and patterns for building a Relay-Compliant API as well.
 
@@ -37,12 +37,12 @@ An example in Graphene
 
 Let’s build a basic GraphQL schema to say "hello" and "goodbye" in Graphene.
 
-When we send a **Query** requesting only one **Field**, ``hello``, and specify a value for the ``name`` **Argument**...
+When we send a **Query** requesting only one **Field**, ``hello``, and specify a value for the ``firstName`` **Argument**...
 
 .. code::
 
     {
-      hello(name: "friend")
+      hello(firstName: "friend")
     }
 
 ...we would expect the following Response containing only the data requested (the ``goodbye`` field is not resolved).
@@ -59,15 +59,15 @@ When we send a **Query** requesting only one **Field**, ``hello``, and specify a
 Requirements
 ~~~~~~~~~~~~
 
--  Python (2.7, 3.4, 3.5, 3.6, pypy)
+-  Python (3.8, 3.9, 3.10, 3.11, 3.12, pypy)
--  Graphene (2.0)
+-  Graphene (3.0)
 
 Project setup
 ~~~~~~~~~~~~~
 
 .. code:: bash
 
-    pip install "graphene>=2.0"
+    pip install "graphene>=3.0"
 
 Creating a basic Schema
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -79,14 +79,15 @@ In Graphene, we can define a simple schema using the following code:
     from graphene import ObjectType, String, Schema
 
     class Query(ObjectType):
-        # this defines a Field `hello` in our Schema with a single Argument `name`
+        # this defines a Field `hello` in our Schema with a single Argument `first_name`
-        hello = String(name=String(default_value="stranger"))
+        # By default, the argument name will automatically be camel-based into firstName in the generated schema
+        hello = String(first_name=String(default_value="stranger"))
         goodbye = String()
 
         # our Resolver method takes the GraphQL context (root, info) as well as
-        # Argument (name) for the Field and returns data for the query Response
+        # Argument (first_name) for the Field and returns data for the query Response
-        def resolve_hello(root, info, name):
+        def resolve_hello(root, info, first_name):
-            return f'Hello {name}!'
+            return f'Hello {first_name}!'
 
         def resolve_goodbye(root, info):
             return 'See ya!'
@@ -103,14 +104,14 @@ For each **Field** in our **Schema**, we write a **Resolver** method to fetch da
 Schema Definition Language (SDL)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-In the `GraphQL Schema Definition Language`_, we could describe the fields defined by our example code as show below.
+In the `GraphQL Schema Definition Language`_, we could describe the fields defined by our example code as shown below.
 
 .. _GraphQL Schema Definition Language: https://graphql.org/learn/schema/
 
 .. code::
 
     type Query {
-      hello(name: String = "stranger"): String
+      hello(firstName: String = "stranger"): String
       goodbye: String
     }
 
@@ -130,7 +131,7 @@ Then we can start querying our **Schema** by passing a GraphQL query string to `
     # "Hello stranger!"
 
     # or passing the argument in the query
-    query_with_argument = '{ hello(name: "GraphQL") }'
+    query_with_argument = '{ hello(firstName: "GraphQL") }'
     result = schema.execute(query_with_argument)
     print(result.data['hello'])
     # "Hello GraphQL!"

docs/relay/index.rst

@@ -19,11 +19,8 @@ Useful links
 -  `Getting started with Relay`_
 -  `Relay Global Identification Specification`_
 -  `Relay Cursor Connection Specification`_
--  `Relay input Object Mutation`_
 
-.. _Relay: https://facebook.github.io/relay/docs/en/graphql-server-specification.html
+.. _Relay: https://relay.dev/docs/guides/graphql-server-specification/
-.. _Relay specification: https://facebook.github.io/relay/graphql/objectidentification.htm#sec-Node-root-field
+.. _Getting started with Relay: https://relay.dev/docs/getting-started/step-by-step-guide/
-.. _Getting started with Relay: https://facebook.github.io/relay/docs/en/quick-start-guide.html
+.. _Relay Global Identification Specification: https://relay.dev/graphql/objectidentification.htm
-.. _Relay Global Identification Specification: https://facebook.github.io/relay/graphql/objectidentification.htm
+.. _Relay Cursor Connection Specification: https://relay.dev/graphql/connections.htm
-.. _Relay Cursor Connection Specification: https://facebook.github.io/relay/graphql/connections.htm
-.. _Relay input Object Mutation: https://facebook.github.io/relay/graphql/mutations.htm

docs/relay/nodes.rst

@@ -51,20 +51,20 @@ Example of a custom node:
             name = 'Node'
 
         @staticmethod
-        def to_global_id(type, id):
+        def to_global_id(type_, id):
-            return '{}:{}'.format(type, id)
+            return f"{type_}:{id}"
 
         @staticmethod
         def get_node_from_global_id(info, global_id, only_type=None):
-            type, id = global_id.split(':')
+            type_, id = global_id.split(':')
             if only_type:
                 # We assure that the node type that we want to retrieve
                 # is the same that was indicated in the field type
-                assert type == only_type._meta.name, 'Received not compatible node.'
+                assert type_ == only_type._meta.name, 'Received not compatible node.'
 
-            if type == 'User':
+            if type_ == 'User':
                 return get_user(id)
-            elif type == 'Photo':
+            elif type_ == 'Photo':
                 return get_photo(id)
 
 

docs/requirements.txt

@@ -1,5 +1,5 @@
 # Required library
-Sphinx==1.5.3
+Sphinx==6.1.3
-sphinx-autobuild==0.7.1
+sphinx-autobuild==2021.3.14
 # Docs template
 http://graphene-python.org/sphinx_graphene_theme.zip

docs/testing/index.rst

@@ -69,43 +69,3 @@ You can also add extra keyword arguments to the ``execute`` method, such as
                 'hey': 'hello Peter!'
             }
         }
-
-
-Snapshot testing
-~~~~~~~~~~~~~~~~
-
-As our APIs evolve, we need to know when our changes introduce any breaking changes that might break
-some of the clients of our GraphQL app.
-
-However, writing tests and replicate the same response we expect from our GraphQL application can be
-tedious and repetitive task, and sometimes it's easier to skip this process.
-
-Because of that, we recommend the usage of `SnapshotTest <https://github.com/syrusakbary/snapshottest/>`_.
-
-SnapshotTest let us write all this tests in a breeze, as creates automatically the ``snapshots`` for us
-the first time the test is executed.
-
-
-Here is a simple example on how our tests will look if we use ``pytest``:
-
-.. code:: python
-
-    def test_hey(snapshot):
-        client = Client(my_schema)
-        # This will create a snapshot dir and a snapshot file
-        # the first time the test is executed, with the response
-        # of the execution.
-        snapshot.assert_match(client.execute('''{ hey }'''))
-
-
-If we are using ``unittest``:
-
-.. code:: python
-
-    from snapshottest import TestCase
-
-    class APITestCase(TestCase):
-        def test_api_me(self):
-            """Testing the API for /me"""
-            client = Client(my_schema)
-            self.assertMatchSnapshot(client.execute('''{ hey }'''))

docs/types/enums.rst

@@ -61,7 +61,8 @@ you can add description etc. to your enum without changing the original:
 
     graphene.Enum.from_enum(
         AlreadyExistingPyEnum,
-        description=lambda v: return 'foo' if v == AlreadyExistingPyEnum.Foo else 'bar')
+        description=lambda v: return 'foo' if v == AlreadyExistingPyEnum.Foo else 'bar'
+    )
 
 
 Notes
@@ -76,6 +77,7 @@ In the Python ``Enum`` implementation you can access a member by initing the Enu
 .. code:: python
 
     from enum import Enum
+
     class Color(Enum):
         RED = 1
         GREEN = 2
@@ -84,11 +86,12 @@ In the Python ``Enum`` implementation you can access a member by initing the Enu
     assert Color(1) == Color.RED
 
 
-However, in Graphene ``Enum`` you need to call get to have the same effect:
+However, in Graphene ``Enum`` you need to call `.get` to have the same effect:
 
 .. code:: python
 
     from graphene import Enum
+
     class Color(Enum):
         RED = 1
         GREEN = 2

docs/types/interfaces.rst

@@ -44,7 +44,7 @@ Both of these types have all of the fields from the ``Character`` interface,
 but also bring in extra fields, ``home_planet``, ``starships`` and
 ``primary_function``, that are specific to that particular type of character.
 
-The full GraphQL schema defition will look like this:
+The full GraphQL schema definition will look like this:
 
 .. code::
 

docs/types/mutations.rst

@@ -85,9 +85,9 @@ We should receive:
 
 InputFields and InputObjectTypes
 ----------------------------------
-InputFields are used in mutations to allow nested input data for mutations
+InputFields are used in mutations to allow nested input data for mutations.
 
-To use an InputField you define an InputObjectType that specifies the structure of your input data
+To use an InputField you define an InputObjectType that specifies the structure of your input data:
 
 
 .. code:: python
@@ -104,7 +104,6 @@ To use an InputField you define an InputObjectType that specifies the structure
 
         person = graphene.Field(Person)
 
-        @staticmethod
         def mutate(root, info, person_data=None):
             person = Person(
                 name=person_data.name,
@@ -113,7 +112,7 @@ To use an InputField you define an InputObjectType that specifies the structure
             return CreatePerson(person=person)
 
 
-Note that  **name** and **age** are part of **person_data** now
+Note that  **name** and **age** are part of **person_data** now.
 
 Using the above mutation your new query would look like this:
 
@@ -129,7 +128,7 @@ Using the above mutation your new query would look like this:
     }
 
 InputObjectTypes can also be fields of InputObjectTypes allowing you to have
-as complex of input data as you need
+as complex of input data as you need:
 
 .. code:: python
 
@@ -161,7 +160,7 @@ To return an existing ObjectType instead of a mutation-specific type, set the **
         def mutate(root, info, name):
             return Person(name=name)
 
-Then, if we query (``schema.execute(query_str)``) the following:
+Then, if we query (``schema.execute(query_str)``) with the following:
 
 .. code::
 

docs/types/objecttypes.rst

@@ -52,6 +52,7 @@ Resolvers are lazily executed, so if a field is not included in a query, its res
 Each field on an *ObjectType* in Graphene should have a corresponding resolver method to fetch data. This resolver method should match the field name. For example, in the ``Person`` type above, the ``full_name`` field is resolved by the method ``resolve_full_name``.
 
 Each resolver method takes the parameters:
+
 * :ref:`ResolverParamParent` for the value object use to resolve most fields
 * :ref:`ResolverParamInfo` for query and schema meta information and per-request context
 * :ref:`ResolverParamGraphQLArguments` as defined on the **Field**.
@@ -79,6 +80,10 @@ If we have a schema with Person type and one field on the root query.
 
     from graphene import ObjectType, String, Field
 
+    def get_human(name):
+        first_name, last_name = name.split()
+        return Person(first_name, last_name)
+
     class Person(ObjectType):
         full_name = String()
 
@@ -101,7 +106,7 @@ When we execute a query against that schema.
     query_string = "{ me { fullName } }"
     result = schema.execute(query_string)
 
-    assert result.data["me"] == {"fullName": "Luke Skywalker")
+    assert result.data["me"] == {"fullName": "Luke Skywalker"}
 
 Then we go through the following steps to resolve this query:
 
@@ -158,6 +163,22 @@ You can then execute the following query:
         }
     }
 
+*Note:* There are several arguments to a field that are "reserved" by Graphene
+(see :ref:`fields-mounted-types`).
+You can still define an argument that clashes with one of these fields by using
+the ``args`` parameter like so:
+
+.. code:: python
+
+    from graphene import ObjectType, Field, String
+
+    class Query(ObjectType):
+        answer = String(args={'description': String()})
+
+        def resolve_answer(parent, info, description):
+            return description
+
+
 Convenience Features of Graphene Resolvers
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -331,7 +352,7 @@ A field can use a custom resolver from outside the class:
     from graphene import ObjectType, String
 
     def resolve_full_name(person, info):
-        return '{} {}'.format(person.first_name, person.last_name)
+        return f"{person.first_name} {person.last_name}"
 
     class Person(ObjectType):
         first_name = String()

docs/types/scalars.rst

@@ -3,6 +3,11 @@
 Scalars
 =======
 
+Scalar types represent concrete values at the leaves of a query. There are
+several built in types that Graphene provides out of the box which represent common
+values in Python. You can also create your own Scalar types to better express
+values that you might have in your data model.
+
 All Scalar types accept the following arguments. All are optional:
 
 ``name``: *string*
@@ -27,34 +32,39 @@ All Scalar types accept the following arguments. All are optional:
 
 
 
-Base scalars
+Built in scalars
-------------
+----------------
 
-Graphene defines the following base Scalar Types:
+Graphene defines the following base Scalar Types that match the default `GraphQL types <https://graphql.org/learn/schema/#scalar-types>`_:
 
 ``graphene.String``
+^^^^^^^^^^^^^^^^^^^
 
     Represents textual data, represented as UTF-8
     character sequences. The String type is most often used by GraphQL to
     represent free-form human-readable text.
 
 ``graphene.Int``
+^^^^^^^^^^^^^^^^
 
     Represents non-fractional signed whole numeric
     values. Int is a signed 32‐bit integer per the
     `GraphQL spec <https://facebook.github.io/graphql/June2018/#sec-Int>`_
 
 ``graphene.Float``
+^^^^^^^^^^^^^^^^^^
 
     Represents signed double-precision fractional
     values as specified by
     `IEEE 754 <http://en.wikipedia.org/wiki/IEEE_floating_point>`_.
 
 ``graphene.Boolean``
+^^^^^^^^^^^^^^^^^^^^
 
     Represents `true` or `false`.
 
 ``graphene.ID``
+^^^^^^^^^^^^^^^
 
     Represents a unique identifier, often used to
     refetch an object or as key for a cache. The ID type appears in a JSON
@@ -62,24 +72,183 @@ Graphene defines the following base Scalar Types:
     When expected as an input type, any string (such as `"4"`) or integer
     (such as `4`) input value will be accepted as an ID.
 
-Graphene also provides custom scalars for Dates, Times, and JSON:
+----
 
-``graphene.types.datetime.Date``
+Graphene also provides custom scalars for common values:
+
+``graphene.Date``
+^^^^^^^^^^^^^^^^^
 
     Represents a Date value as specified by `iso8601 <https://en.wikipedia.org/wiki/ISO_8601>`_.
 
-``graphene.types.datetime.DateTime``
+.. code:: python
+
+    import datetime
+    from graphene import Schema, ObjectType, Date
+
+    class Query(ObjectType):
+        one_week_from = Date(required=True, date_input=Date(required=True))
+
+        def resolve_one_week_from(root, info, date_input):
+            assert date_input == datetime.date(2006, 1, 2)
+            return date_input + datetime.timedelta(weeks=1)
+
+    schema = Schema(query=Query)
+
+    results = schema.execute("""
+        query {
+            oneWeekFrom(dateInput: "2006-01-02")
+        }
+    """)
+
+    assert results.data == {"oneWeekFrom": "2006-01-09"}
+
+
+``graphene.DateTime``
+^^^^^^^^^^^^^^^^^^^^^
 
     Represents a DateTime value as specified by `iso8601 <https://en.wikipedia.org/wiki/ISO_8601>`_.
 
-``graphene.types.datetime.Time``
+.. code:: python
+
+    import datetime
+    from graphene import Schema, ObjectType, DateTime
+
+    class Query(ObjectType):
+        one_hour_from = DateTime(required=True, datetime_input=DateTime(required=True))
+
+        def resolve_one_hour_from(root, info, datetime_input):
+            assert datetime_input == datetime.datetime(2006, 1, 2, 15, 4, 5)
+            return datetime_input + datetime.timedelta(hours=1)
+
+    schema = Schema(query=Query)
+
+    results = schema.execute("""
+        query {
+            oneHourFrom(datetimeInput: "2006-01-02T15:04:05")
+        }
+    """)
+
+    assert results.data == {"oneHourFrom": "2006-01-02T16:04:05"}
+
+``graphene.Time``
+^^^^^^^^^^^^^^^^^
 
     Represents a Time value as specified by `iso8601 <https://en.wikipedia.org/wiki/ISO_8601>`_.
 
-``graphene.types.json.JSONString``
+.. code:: python
+
+    import datetime
+    from graphene import Schema, ObjectType, Time
+
+    class Query(ObjectType):
+        one_hour_from = Time(required=True, time_input=Time(required=True))
+
+        def resolve_one_hour_from(root, info, time_input):
+            assert time_input == datetime.time(15, 4, 5)
+            tmp_time_input = datetime.datetime.combine(datetime.date(1, 1, 1), time_input)
+            return (tmp_time_input + datetime.timedelta(hours=1)).time()
+
+    schema = Schema(query=Query)
+
+    results = schema.execute("""
+        query {
+            oneHourFrom(timeInput: "15:04:05")
+        }
+    """)
+
+    assert results.data == {"oneHourFrom": "16:04:05"}
+
+``graphene.Decimal``
+^^^^^^^^^^^^^^^^^^^^
+
+    Represents a Python Decimal value.
+
+.. code:: python
+
+    import decimal
+    from graphene import Schema, ObjectType, Decimal
+
+    class Query(ObjectType):
+        add_one_to = Decimal(required=True, decimal_input=Decimal(required=True))
+
+        def resolve_add_one_to(root, info, decimal_input):
+            assert decimal_input == decimal.Decimal("10.50")
+            return decimal_input + decimal.Decimal("1")
+
+    schema = Schema(query=Query)
+
+    results = schema.execute("""
+        query {
+            addOneTo(decimalInput: "10.50")
+        }
+    """)
+
+    assert results.data == {"addOneTo": "11.50"}
+
+``graphene.JSONString``
+^^^^^^^^^^^^^^^^^^^^^^^
 
     Represents a JSON string.
 
+.. code:: python
+
+    from graphene import Schema, ObjectType, JSONString, String
+
+    class Query(ObjectType):
+        update_json_key = JSONString(
+            required=True,
+            json_input=JSONString(required=True),
+            key=String(required=True),
+            value=String(required=True)
+        )
+
+        def resolve_update_json_key(root, info, json_input, key, value):
+            assert json_input == {"name": "Jane"}
+            json_input[key] = value
+            return json_input
+
+    schema = Schema(query=Query)
+
+    results = schema.execute("""
+        query {
+            updateJsonKey(jsonInput: "{\\"name\\": \\"Jane\\"}", key: "name", value: "Beth")
+        }
+    """)
+
+    assert results.data == {"updateJsonKey": "{\"name\": \"Beth\"}"}
+
+
+``graphene.Base64``
+^^^^^^^^^^^^^^^^^^^
+
+    Represents a Base64 encoded string.
+
+.. code:: python
+
+    from graphene import Schema, ObjectType, Base64
+
+    class Query(ObjectType):
+        increment_encoded_id = Base64(
+            required=True,
+            base64_input=Base64(required=True),
+        )
+
+        def resolve_increment_encoded_id(root, info, base64_input):
+            assert base64_input == "4"
+            return int(base64_input) + 1
+
+    schema = Schema(query=Query)
+
+    results = schema.execute("""
+        query {
+            incrementEncodedId(base64Input: "NA==")
+        }
+    """)
+
+    assert results.data == {"incrementEncodedId": "NQ=="}
+
+
 
 Custom scalars
 --------------
@@ -101,8 +270,8 @@ The following is an example for creating a DateTime scalar:
             return dt.isoformat()
 
         @staticmethod
-        def parse_literal(node):
+        def parse_literal(node, _variables=None):
-            if isinstance(node, ast.StringValue):
+            if isinstance(node, ast.StringValueNode):
                 return datetime.datetime.strptime(
                     node.value, "%Y-%m-%dT%H:%M:%S.%f")
 

docs/types/schema.rst

@@ -1,11 +1,11 @@
 Schema
 ======
 
-A GraphQL **Schema** defines the types and relationship between **Fields** in your API.
+A GraphQL **Schema** defines the types and relationships between **Fields** in your API.
 
 A Schema is created by supplying the root :ref:`ObjectType` of each operation, query (mandatory), mutation and subscription.
 
-Schema will collect all type definitions related to the root operations and then supplied to the validator and executor.
+Schema will collect all type definitions related to the root operations and then supply them to the validator and executor.
 
 .. code:: python
 
@@ -15,11 +15,11 @@ Schema will collect all type definitions related to the root operations and then
         subscription=MyRootSubscription
     )
 
-A Root Query is just a special :ref:`ObjectType` that :ref:`defines the fields <Scalars>` that are the entrypoint for your API. Root Mutation and Root Subscription are similar to Root Query, but for different operation types:
+A Root Query is just a special :ref:`ObjectType` that defines the fields that are the entrypoint for your API. Root Mutation and Root Subscription are similar to Root Query, but for different operation types:
 
 * Query fetches data
-* Mutation to changes data and retrieve the changes
+* Mutation changes data and retrieves the changes
-* Subscription to sends changes to clients in real time
+* Subscription sends changes to clients in real-time
 
 Review the `GraphQL documentation on Schema`_ for a brief overview of fields, schema and operations.
 
@@ -44,7 +44,7 @@ There are some cases where the schema cannot access all of the types that we pla
 For example, when a field returns an ``Interface``, the schema doesn't know about any of the
 implementations.
 
-In this case, we need to use the ``types`` argument when creating the Schema.
+In this case, we need to use the ``types`` argument when creating the Schema:
 
 
 .. code:: python
@@ -56,14 +56,14 @@ In this case, we need to use the ``types`` argument when creating the Schema.
 
 .. _SchemaAutoCamelCase:
 
-Auto CamelCase field names
+Auto camelCase field names
 --------------------------
 
 By default all field and argument names (that are not
 explicitly set with the ``name`` arg) will be converted from
 ``snake_case`` to ``camelCase`` (as the API is usually being consumed by a js/mobile client)
 
-For example with the ObjectType
+For example with the ObjectType the ``last_name`` field name is converted to ``lastName``:
 
 .. code:: python
 
@@ -71,12 +71,10 @@ For example with the ObjectType
         last_name = graphene.String()
         other_name = graphene.String(name='_other_Name')
 
-the ``last_name`` field name is converted to ``lastName``.
-
 In case you don't want to apply this transformation, provide a ``name`` argument to the field constructor.
 ``other_name`` converts to ``_other_Name`` (without further transformations).
 
-Your query should look like
+Your query should look like:
 
 .. code::
 
@@ -86,7 +84,7 @@ Your query should look like
     }
 
 
-To disable this behavior, set the ``auto_camelcase`` to ``False`` upon schema instantiation.
+To disable this behavior, set the ``auto_camelcase`` to ``False`` upon schema instantiation:
 
 .. code:: python
 

docs/types/unions.rst

@@ -7,7 +7,7 @@ to specify any common fields between the types.
 The basics:
 
 - Each Union is a Python class that inherits from ``graphene.Union``.
-- Unions don't have any fields on it, just links to the possible objecttypes.
+- Unions don't have any fields on it, just links to the possible ObjectTypes.
 
 Quick example
 -------------

examples/complex_example.py

@@ -7,7 +7,7 @@ class GeoInput(graphene.InputObjectType):
 
     @property
     def latlng(self):
-        return "({},{})".format(self.lat, self.lng)
+        return f"({self.lat},{self.lng})"
 
 
 class Address(graphene.ObjectType):
@@ -17,7 +17,7 @@ class Address(graphene.ObjectType):
 class Query(graphene.ObjectType):
     address = graphene.Field(Address, geo=GeoInput(required=True))
 
-    def resolve_address(self, info, geo):
+    def resolve_address(root, info, geo):
         return Address(latlng=geo.latlng)
 
 
@@ -27,7 +27,7 @@ class CreateAddress(graphene.Mutation):
 
     Output = Address
 
-    def mutate(self, info, geo):
+    def mutate(root, info, geo):
         return Address(latlng=geo.latlng)
 
 

examples/context_example.py

@@ -9,7 +9,7 @@ class User(graphene.ObjectType):
 class Query(graphene.ObjectType):
     me = graphene.Field(User)
 
-    def resolve_me(self, info):
+    def resolve_me(root, info):
         return info.context["user"]
 
 

examples/simple_example.py

@@ -8,10 +8,9 @@ class Patron(graphene.ObjectType):
 
 
 class Query(graphene.ObjectType):
-
     patron = graphene.Field(Patron)
 
-    def resolve_patron(self, info):
+    def resolve_patron(root, info):
         return Patron(id=1, name="Syrus", age=27)
 
 

examples/starwars/schema.py

@@ -39,13 +39,13 @@ class Query(graphene.ObjectType):
     human = graphene.Field(Human, id=graphene.String())
     droid = graphene.Field(Droid, id=graphene.String())
 
-    def resolve_hero(self, info, episode=None):
+    def resolve_hero(root, info, episode=None):
         return get_hero(episode)
 
-    def resolve_human(self, info, id):
+    def resolve_human(root, info, id):
         return get_human(id)
 
-    def resolve_droid(self, info, id):
+    def resolve_droid(root, info, id):
         return get_droid(id)
 
 

examples/starwars/tests/snapshots/snap_test_query.py

@@ -1,100 +0,0 @@
-# -*- coding: utf-8 -*-
-# snapshottest: v1 - https://goo.gl/zC4yUc
-from __future__ import unicode_literals
-
-from snapshottest import Snapshot
-
-snapshots = Snapshot()
-
-snapshots["test_hero_name_query 1"] = {"data": {"hero": {"name": "R2-D2"}}}
-
-snapshots["test_hero_name_and_friends_query 1"] = {
-    "data": {
-        "hero": {
-            "id": "2001",
-            "name": "R2-D2",
-            "friends": [
-                {"name": "Luke Skywalker"},
-                {"name": "Han Solo"},
-                {"name": "Leia Organa"},
-            ],
-        }
-    }
-}
-
-snapshots["test_nested_query 1"] = {
-    "data": {
-        "hero": {
-            "name": "R2-D2",
-            "friends": [
-                {
-                    "name": "Luke Skywalker",
-                    "appearsIn": ["NEWHOPE", "EMPIRE", "JEDI"],
-                    "friends": [
-                        {"name": "Han Solo"},
-                        {"name": "Leia Organa"},
-                        {"name": "C-3PO"},
-                        {"name": "R2-D2"},
-                    ],
-                },
-                {
-                    "name": "Han Solo",
-                    "appearsIn": ["NEWHOPE", "EMPIRE", "JEDI"],
-                    "friends": [
-                        {"name": "Luke Skywalker"},
-                        {"name": "Leia Organa"},
-                        {"name": "R2-D2"},
-                    ],
-                },
-                {
-                    "name": "Leia Organa",
-                    "appearsIn": ["NEWHOPE", "EMPIRE", "JEDI"],
-                    "friends": [
-                        {"name": "Luke Skywalker"},
-                        {"name": "Han Solo"},
-                        {"name": "C-3PO"},
-                        {"name": "R2-D2"},
-                    ],
-                },
-            ],
-        }
-    }
-}
-
-snapshots["test_fetch_luke_query 1"] = {"data": {"human": {"name": "Luke Skywalker"}}}
-
-snapshots["test_fetch_some_id_query 1"] = {
-    "data": {"human": {"name": "Luke Skywalker"}}
-}
-
-snapshots["test_fetch_some_id_query2 1"] = {"data": {"human": {"name": "Han Solo"}}}
-
-snapshots["test_invalid_id_query 1"] = {"data": {"human": None}}
-
-snapshots["test_fetch_luke_aliased 1"] = {"data": {"luke": {"name": "Luke Skywalker"}}}
-
-snapshots["test_fetch_luke_and_leia_aliased 1"] = {
-    "data": {"luke": {"name": "Luke Skywalker"}, "leia": {"name": "Leia Organa"}}
-}
-
-snapshots["test_duplicate_fields 1"] = {
-    "data": {
-        "luke": {"name": "Luke Skywalker", "homePlanet": "Tatooine"},
-        "leia": {"name": "Leia Organa", "homePlanet": "Alderaan"},
-    }
-}
-
-snapshots["test_use_fragment 1"] = {
-    "data": {
-        "luke": {"name": "Luke Skywalker", "homePlanet": "Tatooine"},
-        "leia": {"name": "Leia Organa", "homePlanet": "Alderaan"},
-    }
-}
-
-snapshots["test_check_type_of_r2 1"] = {
-    "data": {"hero": {"__typename": "Droid", "name": "R2-D2"}}
-}
-
-snapshots["test_check_type_of_luke 1"] = {
-    "data": {"hero": {"__typename": "Human", "name": "Luke Skywalker"}}
-}

examples/starwars/tests/test_query.py

@@ -8,19 +8,19 @@ setup()
 client = Client(schema)
 
 
-def test_hero_name_query(snapshot):
+def test_hero_name_query():
-    query = """
+    result = client.execute("""
         query HeroNameQuery {
           hero {
             name
           }
         }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {"data": {"hero": {"name": "R2-D2"}}}
 
 
-def test_hero_name_and_friends_query(snapshot):
+def test_hero_name_and_friends_query():
-    query = """
+    result = client.execute("""
         query HeroNameAndFriendsQuery {
           hero {
             id
@@ -30,12 +30,24 @@ def test_hero_name_and_friends_query(snapshot):
             }
           }
         }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {
+        "data": {
+            "hero": {
+                "id": "2001",
+                "name": "R2-D2",
+                "friends": [
+                    {"name": "Luke Skywalker"},
+                    {"name": "Han Solo"},
+                    {"name": "Leia Organa"},
+                ],
+            }
+        }
+    }
 
 
-def test_nested_query(snapshot):
+def test_nested_query():
-    query = """
+    result = client.execute("""
         query NestedQuery {
           hero {
             name
@@ -48,70 +60,113 @@ def test_nested_query(snapshot):
             }
           }
         }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {
+        "data": {
+            "hero": {
+                "name": "R2-D2",
+                "friends": [
+                    {
+                        "name": "Luke Skywalker",
+                        "appearsIn": ["NEWHOPE", "EMPIRE", "JEDI"],
+                        "friends": [
+                            {"name": "Han Solo"},
+                            {"name": "Leia Organa"},
+                            {"name": "C-3PO"},
+                            {"name": "R2-D2"},
+                        ],
+                    },
+                    {
+                        "name": "Han Solo",
+                        "appearsIn": ["NEWHOPE", "EMPIRE", "JEDI"],
+                        "friends": [
+                            {"name": "Luke Skywalker"},
+                            {"name": "Leia Organa"},
+                            {"name": "R2-D2"},
+                        ],
+                    },
+                    {
+                        "name": "Leia Organa",
+                        "appearsIn": ["NEWHOPE", "EMPIRE", "JEDI"],
+                        "friends": [
+                            {"name": "Luke Skywalker"},
+                            {"name": "Han Solo"},
+                            {"name": "C-3PO"},
+                            {"name": "R2-D2"},
+                        ],
+                    },
+                ],
+            }
+        }
+    }
 
 
-def test_fetch_luke_query(snapshot):
+def test_fetch_luke_query():
-    query = """
+    result = client.execute("""
         query FetchLukeQuery {
           human(id: "1000") {
             name
           }
         }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {"data": {"human": {"name": "Luke Skywalker"}}}
 
 
-def test_fetch_some_id_query(snapshot):
+def test_fetch_some_id_query():
-    query = """
+    result = client.execute(
+        """
         query FetchSomeIDQuery($someId: String!) {
           human(id: $someId) {
             name
           }
         }
-    """
+    """,
-    params = {"someId": "1000"}
+        variables={"someId": "1000"},
-    snapshot.assert_match(client.execute(query, variables=params))
+    )
+    assert result == {"data": {"human": {"name": "Luke Skywalker"}}}
 
 
-def test_fetch_some_id_query2(snapshot):
+def test_fetch_some_id_query2():
-    query = """
+    result = client.execute(
+        """
         query FetchSomeIDQuery($someId: String!) {
           human(id: $someId) {
             name
           }
         }
-    """
+    """,
-    params = {"someId": "1002"}
+        variables={"someId": "1002"},
-    snapshot.assert_match(client.execute(query, variables=params))
+    )
+    assert result == {"data": {"human": {"name": "Han Solo"}}}
 
 
-def test_invalid_id_query(snapshot):
+def test_invalid_id_query():
-    query = """
+    result = client.execute(
+        """
         query humanQuery($id: String!) {
           human(id: $id) {
             name
           }
         }
-    """
+    """,
-    params = {"id": "not a valid id"}
+        variables={"id": "not a valid id"},
-    snapshot.assert_match(client.execute(query, variables=params))
+    )
+    assert result == {"data": {"human": None}}
 
 
-def test_fetch_luke_aliased(snapshot):
+def test_fetch_luke_aliased():
-    query = """
+    result = client.execute("""
         query FetchLukeAliased {
           luke: human(id: "1000") {
             name
           }
         }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {"data": {"luke": {"name": "Luke Skywalker"}}}
 
 
-def test_fetch_luke_and_leia_aliased(snapshot):
+def test_fetch_luke_and_leia_aliased():
-    query = """
+    result = client.execute("""
         query FetchLukeAndLeiaAliased {
           luke: human(id: "1000") {
             name
@@ -120,12 +175,14 @@ def test_fetch_luke_and_leia_aliased(snapshot):
             name
           }
         }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {
+        "data": {"luke": {"name": "Luke Skywalker"}, "leia": {"name": "Leia Organa"}}
+    }
 
 
-def test_duplicate_fields(snapshot):
+def test_duplicate_fields():
-    query = """
+    result = client.execute("""
         query DuplicateFields {
           luke: human(id: "1000") {
             name
@@ -136,12 +193,17 @@ def test_duplicate_fields(snapshot):
             homePlanet
           }
         }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {
+        "data": {
+            "luke": {"name": "Luke Skywalker", "homePlanet": "Tatooine"},
+            "leia": {"name": "Leia Organa", "homePlanet": "Alderaan"},
+        }
+    }
 
 
-def test_use_fragment(snapshot):
+def test_use_fragment():
-    query = """
+    result = client.execute("""
         query UseFragment {
           luke: human(id: "1000") {
             ...HumanFragment
@@ -154,29 +216,36 @@ def test_use_fragment(snapshot):
           name
           homePlanet
         }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {
+        "data": {
+            "luke": {"name": "Luke Skywalker", "homePlanet": "Tatooine"},
+            "leia": {"name": "Leia Organa", "homePlanet": "Alderaan"},
+        }
+    }
 
 
-def test_check_type_of_r2(snapshot):
+def test_check_type_of_r2():
-    query = """
+    result = client.execute("""
         query CheckTypeOfR2 {
           hero {
             __typename
             name
           }
         }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {"data": {"hero": {"__typename": "Droid", "name": "R2-D2"}}}
 
 
-def test_check_type_of_luke(snapshot):
+def test_check_type_of_luke():
-    query = """
+    result = client.execute("""
         query CheckTypeOfLuke {
           hero(episode: EMPIRE) {
             __typename
             name
           }
         }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {
+        "data": {"hero": {"__typename": "Human", "name": "Luke Skywalker"}}
+    }

examples/starwars_relay/schema.py

@@ -64,10 +64,10 @@ class Query(graphene.ObjectType):
     empire = graphene.Field(Faction)
     node = relay.Node.Field()
 
-    def resolve_rebels(self, info):
+    def resolve_rebels(root, info):
         return get_rebels()
 
-    def resolve_empire(self, info):
+    def resolve_empire(root, info):
         return get_empire()
 
 

examples/starwars_relay/tests/snapshots/snap_test_connections.py

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-# snapshottest: v1 - https://goo.gl/zC4yUc
-from __future__ import unicode_literals
-
-from snapshottest import Snapshot
-
-snapshots = Snapshot()
-
-snapshots["test_correct_fetch_first_ship_rebels 1"] = {
-    "data": {
-        "rebels": {
-            "name": "Alliance to Restore the Republic",
-            "ships": {
-                "pageInfo": {
-                    "startCursor": "YXJyYXljb25uZWN0aW9uOjA=",
-                    "endCursor": "YXJyYXljb25uZWN0aW9uOjA=",
-                    "hasNextPage": True,
-                    "hasPreviousPage": False,
-                },
-                "edges": [
-                    {"cursor": "YXJyYXljb25uZWN0aW9uOjA=", "node": {"name": "X-Wing"}}
-                ],
-            },
-        }
-    }
-}

examples/starwars_relay/tests/snapshots/snap_test_mutation.py

@@ -1,28 +0,0 @@
-# -*- coding: utf-8 -*-
-# snapshottest: v1 - https://goo.gl/zC4yUc
-from __future__ import unicode_literals
-
-from snapshottest import Snapshot
-
-snapshots = Snapshot()
-
-snapshots["test_mutations 1"] = {
-    "data": {
-        "introduceShip": {
-            "ship": {"id": "U2hpcDo5", "name": "Peter"},
-            "faction": {
-                "name": "Alliance to Restore the Republic",
-                "ships": {
-                    "edges": [
-                        {"node": {"id": "U2hpcDox", "name": "X-Wing"}},
-                        {"node": {"id": "U2hpcDoy", "name": "Y-Wing"}},
-                        {"node": {"id": "U2hpcDoz", "name": "A-Wing"}},
-                        {"node": {"id": "U2hpcDo0", "name": "Millennium Falcon"}},
-                        {"node": {"id": "U2hpcDo1", "name": "Home One"}},
-                        {"node": {"id": "U2hpcDo5", "name": "Peter"}},
-                    ]
-                },
-            },
-        }
-    }
-}

examples/starwars_relay/tests/snapshots/snap_test_objectidentification.py

@@ -1,119 +0,0 @@
-# -*- coding: utf-8 -*-
-# snapshottest: v1 - https://goo.gl/zC4yUc
-from __future__ import unicode_literals
-
-from snapshottest import Snapshot
-
-
-snapshots = Snapshot()
-
-snapshots["test_correctly_fetches_id_name_rebels 1"] = {
-    "data": {
-        "rebels": {"id": "RmFjdGlvbjox", "name": "Alliance to Restore the Republic"}
-    }
-}
-
-snapshots["test_correctly_refetches_rebels 1"] = {
-    "data": {"node": {"id": "RmFjdGlvbjox", "name": "Alliance to Restore the Republic"}}
-}
-
-snapshots["test_correctly_fetches_id_name_empire 1"] = {
-    "data": {"empire": {"id": "RmFjdGlvbjoy", "name": "Galactic Empire"}}
-}
-
-snapshots["test_correctly_refetches_empire 1"] = {
-    "data": {"node": {"id": "RmFjdGlvbjoy", "name": "Galactic Empire"}}
-}
-
-snapshots["test_correctly_refetches_xwing 1"] = {
-    "data": {"node": {"id": "U2hpcDox", "name": "X-Wing"}}
-}
-
-snapshots[
-    "test_str_schema 1"
-] = '''"""A faction in the Star Wars saga"""
-type Faction implements Node {
-  """The ID of the object"""
-  id: ID!
-
-  """The name of the faction."""
-  name: String
-
-  """The ships used by the faction."""
-  ships(before: String = null, after: String = null, first: Int = null, last: Int = null): ShipConnection
-}
-
-input IntroduceShipInput {
-  shipName: String!
-  factionId: String!
-  clientMutationId: String
-}
-
-type IntroduceShipPayload {
-  ship: Ship
-  faction: Faction
-  clientMutationId: String
-}
-
-type Mutation {
-  introduceShip(input: IntroduceShipInput!): IntroduceShipPayload
-}
-
-"""An object with an ID"""
-interface Node {
-  """The ID of the object"""
-  id: ID!
-}
-
-"""
-The Relay compliant `PageInfo` type, containing data necessary to paginate this connection.
-"""
-type PageInfo {
-  """When paginating forwards, are there more items?"""
-  hasNextPage: Boolean!
-
-  """When paginating backwards, are there more items?"""
-  hasPreviousPage: Boolean!
-
-  """When paginating backwards, the cursor to continue."""
-  startCursor: String
-
-  """When paginating forwards, the cursor to continue."""
-  endCursor: String
-}
-
-type Query {
-  rebels: Faction
-  empire: Faction
-  node(
-    """The ID of the object"""
-    id: ID!
-  ): Node
-}
-
-"""A ship in the Star Wars saga"""
-type Ship implements Node {
-  """The ID of the object"""
-  id: ID!
-
-  """The name of the ship."""
-  name: String
-}
-
-type ShipConnection {
-  """Pagination data for this connection."""
-  pageInfo: PageInfo!
-
-  """Contains the nodes in this connection."""
-  edges: [ShipEdge]!
-}
-
-"""A Relay edge containing a `Ship` and its cursor."""
-type ShipEdge {
-  """The item at the end of the edge"""
-  node: Ship
-
-  """A cursor for use in pagination"""
-  cursor: String!
-}
-'''

examples/starwars_relay/tests/test_connections.py

@@ -8,26 +8,46 @@ setup()
 client = Client(schema)
 
 
-def test_correct_fetch_first_ship_rebels(snapshot):
+def test_correct_fetch_first_ship_rebels():
-    query = """
+    result = client.execute("""
-    query RebelsShipsQuery {
+        query RebelsShipsQuery {
-      rebels {
+          rebels {
-        name,
+            name,
-        ships(first: 1) {
+            ships(first: 1) {
-          pageInfo {
+              pageInfo {
-            startCursor
+                startCursor
-            endCursor
+                endCursor
-            hasNextPage
+                hasNextPage
-            hasPreviousPage
+                hasPreviousPage
-          }
+              }
-          edges {
+              edges {
-            cursor
+                cursor
-            node {
+                node {
-              name
+                  name
+                }
+              }
             }
           }
         }
-      }
+    """)
+    assert result == {
+        "data": {
+            "rebels": {
+                "name": "Alliance to Restore the Republic",
+                "ships": {
+                    "pageInfo": {
+                        "startCursor": "YXJyYXljb25uZWN0aW9uOjA=",
+                        "endCursor": "YXJyYXljb25uZWN0aW9uOjA=",
+                        "hasNextPage": True,
+                        "hasPreviousPage": False,
+                    },
+                    "edges": [
+                        {
+                            "cursor": "YXJyYXljb25uZWN0aW9uOjA=",
+                            "node": {"name": "X-Wing"},
+                        }
+                    ],
+                },
+            }
+        }
     }
-    """
-    snapshot.assert_match(client.execute(query))

examples/starwars_relay/tests/test_mutation.py

@@ -8,26 +8,45 @@ setup()
 client = Client(schema)
 
 
-def test_mutations(snapshot):
+def test_mutations():
-    query = """
+    result = client.execute("""
-    mutation MyMutation {
+        mutation MyMutation {
-      introduceShip(input:{clientMutationId:"abc", shipName: "Peter", factionId: "1"}) {
+          introduceShip(input:{clientMutationId:"abc", shipName: "Peter", factionId: "1"}) {
-        ship {
+            ship {
-          id
+              id
-          name
+              name
-        }
+            }
-        faction {
+            faction {
-          name
+              name
-          ships {
+              ships {
-            edges {
+                edges {
-              node {
+                  node {
-                id
+                    id
-                name
+                    name
+                  }
+                }
               }
             }
           }
         }
-      }
+    """)
+    assert result == {
+        "data": {
+            "introduceShip": {
+                "ship": {"id": "U2hpcDo5", "name": "Peter"},
+                "faction": {
+                    "name": "Alliance to Restore the Republic",
+                    "ships": {
+                        "edges": [
+                            {"node": {"id": "U2hpcDox", "name": "X-Wing"}},
+                            {"node": {"id": "U2hpcDoy", "name": "Y-Wing"}},
+                            {"node": {"id": "U2hpcDoz", "name": "A-Wing"}},
+                            {"node": {"id": "U2hpcDo0", "name": "Millennium Falcon"}},
+                            {"node": {"id": "U2hpcDo1", "name": "Home One"}},
+                            {"node": {"id": "U2hpcDo5", "name": "Peter"}},
+                        ]
+                    },
+                },
+            }
+        }
     }
-    """
-    snapshot.assert_match(client.execute(query))

examples/starwars_relay/tests/test_objectidentification.py

@@ -1,3 +1,5 @@
+import textwrap
+
 from graphene.test import Client
 
 from ..data import setup
@@ -8,24 +10,115 @@ setup()
 client = Client(schema)
 
 
-def test_str_schema(snapshot):
+def test_str_schema():
-    snapshot.assert_match(str(schema))
+    assert str(schema).strip() == textwrap.dedent(
+        '''\
+        type Query {
+          rebels: Faction
+          empire: Faction
+          node(
+            """The ID of the object"""
+            id: ID!
+          ): Node
+        }
+
+        """A faction in the Star Wars saga"""
+        type Faction implements Node {
+          """The ID of the object"""
+          id: ID!
+
+          """The name of the faction."""
+          name: String
+
+          """The ships used by the faction."""
+          ships(before: String, after: String, first: Int, last: Int): ShipConnection
+        }
+
+        """An object with an ID"""
+        interface Node {
+          """The ID of the object"""
+          id: ID!
+        }
+
+        type ShipConnection {
+          """Pagination data for this connection."""
+          pageInfo: PageInfo!
+
+          """Contains the nodes in this connection."""
+          edges: [ShipEdge]!
+        }
+
+        """
+        The Relay compliant `PageInfo` type, containing data necessary to paginate this connection.
+        """
+        type PageInfo {
+          """When paginating forwards, are there more items?"""
+          hasNextPage: Boolean!
+
+          """When paginating backwards, are there more items?"""
+          hasPreviousPage: Boolean!
+
+          """When paginating backwards, the cursor to continue."""
+          startCursor: String
+
+          """When paginating forwards, the cursor to continue."""
+          endCursor: String
+        }
+
+        """A Relay edge containing a `Ship` and its cursor."""
+        type ShipEdge {
+          """The item at the end of the edge"""
+          node: Ship
+
+          """A cursor for use in pagination"""
+          cursor: String!
+        }
+
+        """A ship in the Star Wars saga"""
+        type Ship implements Node {
+          """The ID of the object"""
+          id: ID!
+
+          """The name of the ship."""
+          name: String
+        }
+
+        type Mutation {
+          introduceShip(input: IntroduceShipInput!): IntroduceShipPayload
+        }
+
+        type IntroduceShipPayload {
+          ship: Ship
+          faction: Faction
+          clientMutationId: String
+        }
+
+        input IntroduceShipInput {
+          shipName: String!
+          factionId: String!
+          clientMutationId: String
+        }'''
+    )
 
 
-def test_correctly_fetches_id_name_rebels(snapshot):
+def test_correctly_fetches_id_name_rebels():
-    query = """
+    result = client.execute("""
       query RebelsQuery {
         rebels {
           id
           name
         }
       }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {
+        "data": {
+            "rebels": {"id": "RmFjdGlvbjox", "name": "Alliance to Restore the Republic"}
+        }
+    }
 
 
-def test_correctly_refetches_rebels(snapshot):
+def test_correctly_refetches_rebels():
-    query = """
+    result = client.execute("""
       query RebelsRefetchQuery {
         node(id: "RmFjdGlvbjox") {
           id
@@ -34,24 +127,30 @@ def test_correctly_refetches_rebels(snapshot):
           }
         }
       }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {
+        "data": {
+            "node": {"id": "RmFjdGlvbjox", "name": "Alliance to Restore the Republic"}
+        }
+    }
 
 
-def test_correctly_fetches_id_name_empire(snapshot):
+def test_correctly_fetches_id_name_empire():
-    query = """
+    result = client.execute("""
       query EmpireQuery {
         empire {
           id
           name
         }
       }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {
+        "data": {"empire": {"id": "RmFjdGlvbjoy", "name": "Galactic Empire"}}
+    }
 
 
-def test_correctly_refetches_empire(snapshot):
+def test_correctly_refetches_empire():
-    query = """
+    result = client.execute("""
       query EmpireRefetchQuery {
         node(id: "RmFjdGlvbjoy") {
           id
@@ -60,12 +159,14 @@ def test_correctly_refetches_empire(snapshot):
           }
         }
       }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {
+        "data": {"node": {"id": "RmFjdGlvbjoy", "name": "Galactic Empire"}}
+    }
 
 
-def test_correctly_refetches_xwing(snapshot):
+def test_correctly_refetches_xwing():
-    query = """
+    result = client.execute("""
       query XWingRefetchQuery {
         node(id: "U2hpcDox") {
           id
@@ -74,5 +175,5 @@ def test_correctly_refetches_xwing(snapshot):
           }
         }
       }
-    """
+    """)
-    snapshot.assert_match(client.execute(query))
+    assert result == {"data": {"node": {"id": "U2hpcDox", "name": "X-Wing"}}}

graphene/__init__.py

@@ -1,88 +1,98 @@
 from .pyutils.version import get_version
-
-from .types import (
-    ObjectType,
-    InputObjectType,
-    Interface,
-    Mutation,
-    Field,
-    InputField,
-    Schema,
-    Scalar,
-    String,
-    ID,
-    Int,
-    Float,
-    Boolean,
-    Date,
-    DateTime,
-    Time,
-    Decimal,
-    JSONString,
-    UUID,
-    List,
-    NonNull,
-    Enum,
-    Argument,
-    Dynamic,
-    Union,
-    Context,
-    ResolveInfo,
-)
 from .relay import (
-    Node,
+    BaseGlobalIDType,
-    is_node,
-    GlobalID,
     ClientIDMutation,
     Connection,
     ConnectionField,
+    DefaultGlobalIDType,
+    GlobalID,
+    Node,
     PageInfo,
+    SimpleGlobalIDType,
+    UUIDGlobalIDType,
+    is_node,
+)
+from .types import (
+    ID,
+    UUID,
+    Argument,
+    Base64,
+    BigInt,
+    Boolean,
+    Context,
+    Date,
+    DateTime,
+    Decimal,
+    Dynamic,
+    Enum,
+    Field,
+    Float,
+    InputField,
+    InputObjectType,
+    Int,
+    Interface,
+    JSONString,
+    List,
+    Mutation,
+    NonNull,
+    ObjectType,
+    ResolveInfo,
+    Scalar,
+    Schema,
+    String,
+    Time,
+    Union,
 )
-from .utils.resolve_only_args import resolve_only_args
 from .utils.module_loading import lazy_import
+from .utils.resolve_only_args import resolve_only_args
 
-
+VERSION = (3, 4, 3, "final", 0)
-VERSION = (3, 0, 0, "alpha", 1)
 
 
 __version__ = get_version(VERSION)
 
 __all__ = [
     "__version__",
-    "ObjectType",
-    "InputObjectType",
-    "Interface",
-    "Mutation",
-    "Field",
-    "InputField",
-    "Schema",
-    "Scalar",
-    "String",
-    "ID",
-    "Int",
-    "Float",
-    "Enum",
-    "Boolean",
-    "Date",
-    "DateTime",
-    "Time",
-    "Decimal",
-    "JSONString",
-    "UUID",
-    "List",
-    "NonNull",
     "Argument",
-    "Dynamic",
+    "Base64",
-    "Union",
+    "BigInt",
-    "resolve_only_args",
+    "BaseGlobalIDType",
-    "Node",
+    "Boolean",
-    "is_node",
-    "GlobalID",
     "ClientIDMutation",
     "Connection",
     "ConnectionField",
-    "PageInfo",
-    "lazy_import",
     "Context",
+    "Date",
+    "DateTime",
+    "Decimal",
+    "DefaultGlobalIDType",
+    "Dynamic",
+    "Enum",
+    "Field",
+    "Float",
+    "GlobalID",
+    "ID",
+    "InputField",
+    "InputObjectType",
+    "Int",
+    "Interface",
+    "JSONString",
+    "List",
+    "Mutation",
+    "Node",
+    "NonNull",
+    "ObjectType",
+    "PageInfo",
     "ResolveInfo",
+    "Scalar",
+    "Schema",
+    "SimpleGlobalIDType",
+    "String",
+    "Time",
+    "Union",
+    "UUID",
+    "UUIDGlobalIDType",
+    "is_node",
+    "lazy_import",
+    "resolve_only_args",
 ]

graphene/pyutils/init_subclass.py

@@ -1,23 +0,0 @@
-is_init_subclass_available = hasattr(object, "__init_subclass__")
-
-if not is_init_subclass_available:
-
-    class InitSubclassMeta(type):
-        """Metaclass that implements PEP 487 protocol"""
-
-        def __new__(cls, name, bases, ns, **kwargs):
-            __init_subclass__ = ns.pop("__init_subclass__", None)
-            if __init_subclass__:
-                __init_subclass__ = classmethod(__init_subclass__)
-                ns["__init_subclass__"] = __init_subclass__
-            return super(InitSubclassMeta, cls).__new__(cls, name, bases, ns, **kwargs)
-
-        def __init__(cls, name, bases, ns, **kwargs):
-            super(InitSubclassMeta, cls).__init__(name, bases, ns)
-            super_class = super(cls, cls)
-            if hasattr(super_class, "__init_subclass__"):
-                super_class.__init_subclass__.__func__(cls, **kwargs)
-
-
-else:
-    InitSubclassMeta = type  # type: ignore

graphene/pyutils/version.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 import datetime
 import os
 import subprocess
@@ -19,10 +17,7 @@ def get_version(version=None):
     sub = ""
     if version[3] == "alpha" and version[4] == 0:
         git_changeset = get_git_changeset()
-        if git_changeset:
+        sub = ".dev%s" % git_changeset if git_changeset else ".dev"
-            sub = ".dev%s" % git_changeset
-        else:
-            sub = ".dev"
     elif version[3] != "final":
         mapping = {"alpha": "a", "beta": "b", "rc": "rc"}
         sub = mapping[version[3]] + str(version[4])
@@ -76,6 +71,6 @@ def get_git_changeset():
         )
         timestamp = git_log.communicate()[0]
         timestamp = datetime.datetime.utcfromtimestamp(int(timestamp))
-    except:
+    except Exception:
         return None
     return timestamp.strftime("%Y%m%d%H%M%S")

graphene/relay/__init__.py

@@ -1,13 +1,23 @@
 from .node import Node, is_node, GlobalID
 from .mutation import ClientIDMutation
 from .connection import Connection, ConnectionField, PageInfo
+from .id_type import (
+    BaseGlobalIDType,
+    DefaultGlobalIDType,
+    SimpleGlobalIDType,
+    UUIDGlobalIDType,
+)
 
 __all__ = [
-    "Node",
+    "BaseGlobalIDType",
-    "is_node",
-    "GlobalID",
     "ClientIDMutation",
     "Connection",
     "ConnectionField",
+    "DefaultGlobalIDType",
+    "GlobalID",
+    "Node",
     "PageInfo",
+    "SimpleGlobalIDType",
+    "UUIDGlobalIDType",
+    "is_node",
 ]

graphene/relay/connection.py

@@ -1,6 +1,7 @@
 import re
 from collections.abc import Iterable
 from functools import partial
+from typing import Type
 
 from graphql_relay import connection_from_array
 
@@ -8,7 +9,34 @@ from ..types import Boolean, Enum, Int, Interface, List, NonNull, Scalar, String
 from ..types.field import Field
 from ..types.objecttype import ObjectType, ObjectTypeOptions
 from ..utils.thenables import maybe_thenable
-from .node import is_node
+from .node import is_node, AbstractNode
+
+
+def get_edge_class(
+    connection_class: Type["Connection"],
+    _node: Type[AbstractNode],
+    base_name: str,
+    strict_types: bool = False,
+):
+    edge_class = getattr(connection_class, "Edge", None)
+
+    class EdgeBase:
+        node = Field(
+            NonNull(_node) if strict_types else _node,
+            description="The item at the end of the edge",
+        )
+        cursor = String(required=True, description="A cursor for use in pagination")
+
+    class EdgeMeta:
+        description = f"A Relay edge containing a `{base_name}` and its cursor."
+
+    edge_name = f"{base_name}Edge"
+
+    edge_bases = [edge_class, EdgeBase] if edge_class else [EdgeBase]
+    if not isinstance(edge_class, ObjectType):
+        edge_bases = [*edge_bases, ObjectType]
+
+    return type(edge_name, tuple(edge_bases), {"Meta": EdgeMeta})
 
 
 class PageInfo(ObjectType):
@@ -61,54 +89,43 @@ class Connection(ObjectType):
         abstract = True
 
     @classmethod
-    def __init_subclass_with_meta__(cls, node=None, name=None, **options):
+    def __init_subclass_with_meta__(
-        _meta = ConnectionOptions(cls)
+        cls, node=None, name=None, strict_types=False, _meta=None, **options
-        assert node, "You have to provide a node in {}.Meta".format(cls.__name__)
+    ):
+        if not _meta:
+            _meta = ConnectionOptions(cls)
+        assert node, f"You have to provide a node in {cls.__name__}.Meta"
         assert isinstance(node, NonNull) or issubclass(
             node, (Scalar, Enum, ObjectType, Interface, Union, NonNull)
-        ), ('Received incompatible node "{}" for Connection {}.').format(
+        ), f'Received incompatible node "{node}" for Connection {cls.__name__}.'
-            node, cls.__name__
-        )
 
         base_name = re.sub("Connection$", "", name or cls.__name__) or node._meta.name
         if not name:
-            name = "{}Connection".format(base_name)
+            name = f"{base_name}Connection"
-
-        edge_class = getattr(cls, "Edge", None)
-        _node = node
-
-        class EdgeBase:
-            node = Field(_node, description="The item at the end of the edge")
-            cursor = String(required=True, description="A cursor for use in pagination")
-
-        class EdgeMeta:
-            description = "A Relay edge containing a `{}` and its cursor.".format(
-                base_name
-            )
-
-        edge_name = "{}Edge".format(base_name)
-        if edge_class:
-            edge_bases = (edge_class, EdgeBase, ObjectType)
-        else:
-            edge_bases = (EdgeBase, ObjectType)
-
-        edge = type(edge_name, edge_bases, {"Meta": EdgeMeta})
-        cls.Edge = edge
 
         options["name"] = name
+
         _meta.node = node
-        _meta.fields = {
+
-            "page_info": Field(
+        if not _meta.fields:
+            _meta.fields = {}
+
+        if "page_info" not in _meta.fields:
+            _meta.fields["page_info"] = Field(
                 PageInfo,
                 name="pageInfo",
                 required=True,
                 description="Pagination data for this connection.",
-            ),
+            )
-            "edges": Field(
+
-                NonNull(List(edge)),
+        if "edges" not in _meta.fields:
+            edge_class = get_edge_class(cls, node, base_name, strict_types)  # type: ignore
+            cls.Edge = edge_class
+            _meta.fields["edges"] = Field(
+                NonNull(List(NonNull(edge_class) if strict_types else edge_class)),
                 description="Contains the nodes in this connection.",
-            ),
+            )
-        }
+
         return super(Connection, cls).__init_subclass_with_meta__(
             _meta=_meta, **options
         )
@@ -121,19 +138,19 @@ def connection_adapter(cls, edges, pageInfo):
 
 
 class IterableConnectionField(Field):
-    def __init__(self, type, *args, **kwargs):
+    def __init__(self, type_, *args, **kwargs):
         kwargs.setdefault("before", String())
         kwargs.setdefault("after", String())
         kwargs.setdefault("first", Int())
         kwargs.setdefault("last", Int())
-        super(IterableConnectionField, self).__init__(type, *args, **kwargs)
+        super(IterableConnectionField, self).__init__(type_, *args, **kwargs)
 
     @property
     def type(self):
-        type = super(IterableConnectionField, self).type
+        type_ = super(IterableConnectionField, self).type
-        connection_type = type
+        connection_type = type_
-        if isinstance(type, NonNull):
+        if isinstance(type_, NonNull):
-            connection_type = type.of_type
+            connection_type = type_.of_type
 
         if is_node(connection_type):
             raise Exception(
@@ -141,10 +158,10 @@ class IterableConnectionField(Field):
                 "Read more: https://github.com/graphql-python/graphene/blob/v2.0.0/UPGRADE-v2.0.md#node-connections"
             )
 
-        assert issubclass(connection_type, Connection), (
+        assert issubclass(
-            '{} type has to be a subclass of Connection. Received "{}".'
+            connection_type, Connection
-        ).format(self.__class__.__name__, connection_type)
+        ), f'{self.__class__.__name__} type has to be a subclass of Connection. Received "{connection_type}".'
-        return type
+        return type_
 
     @classmethod
     def resolve_connection(cls, connection_type, args, resolved):
@@ -152,9 +169,9 @@ class IterableConnectionField(Field):
             return resolved
 
         assert isinstance(resolved, Iterable), (
-            "Resolved value from the connection field has to be an iterable or instance of {}. "
+            f"Resolved value from the connection field has to be an iterable or instance of {connection_type}. "
-            'Received "{}"'
+            f'Received "{resolved}"'
-        ).format(connection_type, resolved)
+        )
         connection = connection_from_array(
             resolved,
             args,
@@ -175,8 +192,8 @@ class IterableConnectionField(Field):
         on_resolve = partial(cls.resolve_connection, connection_type, args)
         return maybe_thenable(resolved, on_resolve)
 
-    def get_resolver(self, parent_resolver):
+    def wrap_resolve(self, parent_resolver):
-        resolver = super(IterableConnectionField, self).get_resolver(parent_resolver)
+        resolver = super(IterableConnectionField, self).wrap_resolve(parent_resolver)
         return partial(self.connection_resolver, resolver, self.type)
 
 

graphene/relay/id_type.py

@@ -0,0 +1,87 @@
+from graphql_relay import from_global_id, to_global_id
+
+from ..types import ID, UUID
+from ..types.base import BaseType
+
+from typing import Type
+
+
+class BaseGlobalIDType:
+    """
+    Base class that define the required attributes/method for a type.
+    """
+
+    graphene_type: Type[BaseType] = ID
+
+    @classmethod
+    def resolve_global_id(cls, info, global_id):
+        # return _type, _id
+        raise NotImplementedError
+
+    @classmethod
+    def to_global_id(cls, _type, _id):
+        # return _id
+        raise NotImplementedError
+
+
+class DefaultGlobalIDType(BaseGlobalIDType):
+    """
+    Default global ID type: base64 encoded version of "<node type name>: <node id>".
+    """
+
+    graphene_type = ID
+
+    @classmethod
+    def resolve_global_id(cls, info, global_id):
+        try:
+            _type, _id = from_global_id(global_id)
+            if not _type:
+                raise ValueError("Invalid Global ID")
+            return _type, _id
+        except Exception as e:
+            raise Exception(
+                f'Unable to parse global ID "{global_id}". '
+                'Make sure it is a base64 encoded string in the format: "TypeName:id". '
+                f"Exception message: {e}"
+            )
+
+    @classmethod
+    def to_global_id(cls, _type, _id):
+        return to_global_id(_type, _id)
+
+
+class SimpleGlobalIDType(BaseGlobalIDType):
+    """
+    Simple global ID type: simply the id of the object.
+    To be used carefully as the user is responsible for ensuring that the IDs are indeed global
+    (otherwise it could cause request caching issues).
+    """
+
+    graphene_type = ID
+
+    @classmethod
+    def resolve_global_id(cls, info, global_id):
+        _type = info.return_type.graphene_type._meta.name
+        return _type, global_id
+
+    @classmethod
+    def to_global_id(cls, _type, _id):
+        return _id
+
+
+class UUIDGlobalIDType(BaseGlobalIDType):
+    """
+    UUID global ID type.
+    By definition UUID are global so they are used as they are.
+    """
+
+    graphene_type = UUID
+
+    @classmethod
+    def resolve_global_id(cls, info, global_id):
+        _type = info.return_type.graphene_type._meta.name
+        return _type, global_id
+
+    @classmethod
+    def to_global_id(cls, _type, _id):
+        return _id

graphene/relay/mutation.py

@@ -27,7 +27,7 @@ class ClientIDMutation(Mutation):
             input_fields = {}
 
         cls.Input = type(
-            "{}Input".format(base_name),
+            f"{base_name}Input",
             bases,
             dict(input_fields, client_mutation_id=String(name="clientMutationId")),
         )
@@ -39,12 +39,12 @@ class ClientIDMutation(Mutation):
         mutate_and_get_payload = getattr(cls, "mutate_and_get_payload", None)
         if cls.mutate and cls.mutate.__func__ == ClientIDMutation.mutate.__func__:
             assert mutate_and_get_payload, (
-                "{name}.mutate_and_get_payload method is required"
+                f"{name or cls.__name__}.mutate_and_get_payload method is required"
                 " in a ClientIDMutation."
-            ).format(name=name or cls.__name__)
+            )
 
         if not name:
-            name = "{}Payload".format(base_name)
+            name = f"{base_name}Payload"
 
         super(ClientIDMutation, cls).__init_subclass_with_meta__(
             output=None, arguments=arguments, name=name, **options
@@ -58,9 +58,7 @@ class ClientIDMutation(Mutation):
                 payload.client_mutation_id = input.get("client_mutation_id")
             except Exception:
                 raise Exception(
-                    ("Cannot set client_mutation_id in the payload object {}").format(
+                    f"Cannot set client_mutation_id in the payload object {repr(payload)}"
-                        repr(payload)
-                    )
                 )
             return payload
 

graphene/relay/node.py

@@ -1,11 +1,10 @@
 from functools import partial
 from inspect import isclass
 
-from graphql_relay import from_global_id, to_global_id
+from ..types import Field, Interface, ObjectType
-
-from ..types import ID, Field, Interface, ObjectType
 from ..types.interface import InterfaceOptions
 from ..types.utils import get_type
+from .id_type import BaseGlobalIDType, DefaultGlobalIDType
 
 
 def is_node(objecttype):
@@ -18,16 +17,22 @@ def is_node(objecttype):
     if not issubclass(objecttype, ObjectType):
         return False
 
-    for i in objecttype._meta.interfaces:
+    return any(issubclass(i, Node) for i in objecttype._meta.interfaces)
-        if issubclass(i, Node):
-            return True
-
-    return False
 
 
 class GlobalID(Field):
-    def __init__(self, node=None, parent_type=None, required=True, *args, **kwargs):
+    def __init__(
-        super(GlobalID, self).__init__(ID, required=required, *args, **kwargs)
+        self,
+        node=None,
+        parent_type=None,
+        required=True,
+        global_id_type=DefaultGlobalIDType,
+        *args,
+        **kwargs,
+    ):
+        super(GlobalID, self).__init__(
+            global_id_type.graphene_type, required=required, *args, **kwargs
+        )
         self.node = node or Node
         self.parent_type_name = parent_type._meta.name if parent_type else None
 
@@ -37,7 +42,7 @@ class GlobalID(Field):
         parent_type_name = parent_type_name or info.parent_type.name
         return node.to_global_id(parent_type_name, type_id)  # root._meta.name
 
-    def get_resolver(self, parent_resolver):
+    def wrap_resolve(self, parent_resolver):
         return partial(
             self.id_resolver,
             parent_resolver,
@@ -47,20 +52,22 @@ class GlobalID(Field):
 
 
 class NodeField(Field):
-    def __init__(self, node, type=False, **kwargs):
+    def __init__(self, node, type_=False, **kwargs):
         assert issubclass(node, Node), "NodeField can only operate in Nodes"
         self.node_type = node
-        self.field_type = type
+        self.field_type = type_
+        global_id_type = node._meta.global_id_type
 
         super(NodeField, self).__init__(
-            # If we don's specify a type, the field type will be the node
+            # If we don't specify a type, the field type will be the node interface
-            # interface
+            type_ or node,
-            type or node,
+            id=global_id_type.graphene_type(
-            id=ID(required=True, description="The ID of the object"),
+                required=True, description="The ID of the object"
-            **kwargs
+            ),
+            **kwargs,
         )
 
-    def get_resolver(self, parent_resolver):
+    def wrap_resolve(self, parent_resolver):
         return partial(self.node_type.node_resolver, get_type(self.field_type))
 
 
@@ -69,11 +76,23 @@ class AbstractNode(Interface):
         abstract = True
 
     @classmethod
-    def __init_subclass_with_meta__(cls, **options):
+    def __init_subclass_with_meta__(cls, global_id_type=DefaultGlobalIDType, **options):
+        assert issubclass(
+            global_id_type, BaseGlobalIDType
+        ), "Custom ID type need to be implemented as a subclass of BaseGlobalIDType."
         _meta = InterfaceOptions(cls)
-        _meta.fields = {"id": GlobalID(cls, description="The ID of the object")}
+        _meta.global_id_type = global_id_type
+        _meta.fields = {
+            "id": GlobalID(
+                cls, global_id_type=global_id_type, description="The ID of the object"
+            )
+        }
         super(AbstractNode, cls).__init_subclass_with_meta__(_meta=_meta, **options)
 
+    @classmethod
+    def resolve_global_id(cls, info, global_id):
+        return cls._meta.global_id_type.resolve_global_id(info, global_id)
+
 
 class Node(AbstractNode):
     """An object with an ID"""
@@ -88,38 +107,23 @@ class Node(AbstractNode):
 
     @classmethod
     def get_node_from_global_id(cls, info, global_id, only_type=None):
-        try:
+        _type, _id = cls.resolve_global_id(info, global_id)
-            _type, _id = cls.from_global_id(global_id)
-        except Exception as e:
-            raise Exception(
-                (
-                    'Unable to parse global ID "{global_id}". '
-                    'Make sure it is a base64 encoded string in the format: "TypeName:id". '
-                    "Exception message: {exception}".format(
-                        global_id=global_id, exception=str(e)
-                    )
-                )
-            )
 
         graphene_type = info.schema.get_type(_type)
         if graphene_type is None:
-            raise Exception(
+            raise Exception(f'Relay Node "{_type}" not found in schema')
-                'Relay Node "{_type}" not found in schema'.format(_type=_type)
-            )
 
         graphene_type = graphene_type.graphene_type
 
         if only_type:
-            assert graphene_type == only_type, ("Must receive a {} id.").format(
+            assert (
-                only_type._meta.name
+                graphene_type == only_type
-            )
+            ), f"Must receive a {only_type._meta.name} id."
 
         # We make sure the ObjectType implements the "Node" interface
         if cls not in graphene_type._meta.interfaces:
             raise Exception(
-                'ObjectType "{_type}" does not implement the "{cls}" interface.'.format(
+                f'ObjectType "{_type}" does not implement the "{cls}" interface.'
-                    _type=_type, cls=cls
-                )
             )
 
         get_node = getattr(graphene_type, "get_node", None)
@@ -127,9 +131,5 @@ class Node(AbstractNode):
             return get_node(info, _id)
 
     @classmethod
-    def from_global_id(cls, global_id):
+    def to_global_id(cls, type_, id):
-        return from_global_id(global_id)
+        return cls._meta.global_id_type.to_global_id(type_, id)
-
-    @classmethod
-    def to_global_id(cls, type, id):
-        return to_global_id(type, id)

graphene/relay/tests/test_connection.py

@@ -1,7 +1,15 @@
+import re
+
 from pytest import raises
 
 from ...types import Argument, Field, Int, List, NonNull, ObjectType, Schema, String
-from ..connection import Connection, ConnectionField, PageInfo
+from ..connection import (
+    Connection,
+    ConnectionField,
+    PageInfo,
+    ConnectionOptions,
+    get_edge_class,
+)
 from ..node import Node
 
 
@@ -51,6 +59,111 @@ def test_connection_inherit_abstracttype():
     assert list(fields) == ["page_info", "edges", "extra"]
 
 
+def test_connection_extra_abstract_fields():
+    class ConnectionWithNodes(Connection):
+        class Meta:
+            abstract = True
+
+        @classmethod
+        def __init_subclass_with_meta__(cls, node=None, name=None, **options):
+            _meta = ConnectionOptions(cls)
+
+            _meta.fields = {
+                "nodes": Field(
+                    NonNull(List(node)),
+                    description="Contains all the nodes in this connection.",
+                ),
+            }
+
+            return super(ConnectionWithNodes, cls).__init_subclass_with_meta__(
+                node=node, name=name, _meta=_meta, **options
+            )
+
+    class MyObjectConnection(ConnectionWithNodes):
+        class Meta:
+            node = MyObject
+
+        class Edge:
+            other = String()
+
+    assert MyObjectConnection._meta.name == "MyObjectConnection"
+    fields = MyObjectConnection._meta.fields
+    assert list(fields) == ["nodes", "page_info", "edges"]
+    edge_field = fields["edges"]
+    pageinfo_field = fields["page_info"]
+    nodes_field = fields["nodes"]
+
+    assert isinstance(edge_field, Field)
+    assert isinstance(edge_field.type, NonNull)
+    assert isinstance(edge_field.type.of_type, List)
+    assert edge_field.type.of_type.of_type == MyObjectConnection.Edge
+
+    assert isinstance(pageinfo_field, Field)
+    assert isinstance(pageinfo_field.type, NonNull)
+    assert pageinfo_field.type.of_type == PageInfo
+
+    assert isinstance(nodes_field, Field)
+    assert isinstance(nodes_field.type, NonNull)
+    assert isinstance(nodes_field.type.of_type, List)
+    assert nodes_field.type.of_type.of_type == MyObject
+
+
+def test_connection_override_fields():
+    class ConnectionWithNodes(Connection):
+        class Meta:
+            abstract = True
+
+        @classmethod
+        def __init_subclass_with_meta__(cls, node=None, name=None, **options):
+            _meta = ConnectionOptions(cls)
+            base_name = (
+                re.sub("Connection$", "", name or cls.__name__) or node._meta.name
+            )
+
+            edge_class = get_edge_class(cls, node, base_name)
+
+            _meta.fields = {
+                "page_info": Field(
+                    NonNull(
+                        PageInfo,
+                        name="pageInfo",
+                        required=True,
+                        description="Pagination data for this connection.",
+                    )
+                ),
+                "edges": Field(
+                    NonNull(List(NonNull(edge_class))),
+                    description="Contains the nodes in this connection.",
+                ),
+            }
+
+            return super(ConnectionWithNodes, cls).__init_subclass_with_meta__(
+                node=node, name=name, _meta=_meta, **options
+            )
+
+    class MyObjectConnection(ConnectionWithNodes):
+        class Meta:
+            node = MyObject
+
+    assert MyObjectConnection._meta.name == "MyObjectConnection"
+    fields = MyObjectConnection._meta.fields
+    assert list(fields) == ["page_info", "edges"]
+    edge_field = fields["edges"]
+    pageinfo_field = fields["page_info"]
+
+    assert isinstance(edge_field, Field)
+    assert isinstance(edge_field.type, NonNull)
+    assert isinstance(edge_field.type.of_type, List)
+    assert isinstance(edge_field.type.of_type.of_type, NonNull)
+
+    assert edge_field.type.of_type.of_type.of_type.__name__ == "MyObjectEdge"
+
+    # This page info is NonNull
+    assert isinstance(pageinfo_field, Field)
+    assert isinstance(edge_field.type, NonNull)
+    assert pageinfo_field.type.of_type == PageInfo
+
+
 def test_connection_name():
     custom_name = "MyObjectCustomNameConnection"
 
@@ -186,3 +299,20 @@ def test_connectionfield_required():
     executed = schema.execute("{ testConnection { edges { cursor } } }")
     assert not executed.errors
     assert executed.data == {"testConnection": {"edges": []}}
+
+
+def test_connectionfield_strict_types():
+    class MyObjectConnection(Connection):
+        class Meta:
+            node = MyObject
+            strict_types = True
+
+    connection_field = ConnectionField(MyObjectConnection)
+    edges_field_type = connection_field.type._meta.fields["edges"].type
+    assert isinstance(edges_field_type, NonNull)
+
+    edges_list_element_type = edges_field_type.of_type.of_type
+    assert isinstance(edges_list_element_type, NonNull)
+
+    node_field = edges_list_element_type.of_type._meta.fields["node"]
+    assert isinstance(node_field.type, NonNull)

graphene/relay/tests/test_connection_async.py

@@ -51,10 +51,10 @@ letters = {letter: Letter(id=i, letter=letter) for i, letter in enumerate(letter
 def edges(selected_letters):
     return [
         {
-            "node": {"id": base64("Letter:%s" % l.id), "letter": l.letter},
+            "node": {"id": base64("Letter:%s" % letter.id), "letter": letter.letter},
-            "cursor": base64("arrayconnection:%s" % l.id),
+            "cursor": base64("arrayconnection:%s" % letter.id),
         }
-        for l in [letters[i] for i in selected_letters]
+        for letter in [letters[i] for i in selected_letters]
     ]
 
 

graphene/relay/tests/test_connection_query.py

@@ -51,10 +51,10 @@ letters = {letter: Letter(id=i, letter=letter) for i, letter in enumerate(letter
 def edges(selected_letters):
     return [
         {
-            "node": {"id": base64("Letter:%s" % l.id), "letter": l.letter},
+            "node": {"id": base64("Letter:%s" % letter.id), "letter": letter.letter},
-            "cursor": base64("arrayconnection:%s" % l.id),
+            "cursor": base64("arrayconnection:%s" % letter.id),
         }
-        for l in [letters[i] for i in selected_letters]
+        for letter in [letters[i] for i in selected_letters]
     ]
 
 
@@ -66,7 +66,6 @@ def cursor_for(ltr):
 async def execute(args=""):
     if args:
         args = "(" + args + ")"
-
     return await schema.execute_async(
         """
     {
@@ -134,32 +133,28 @@ async def test_respects_an_overly_large_last():
 
 @mark.asyncio
 async def test_respects_first_and_after():
-    await check(
+    await check(f'first: 2, after: "{cursor_for("B")}"', "CD", has_next_page=True)
-        'first: 2, after: "{}"'.format(cursor_for("B")), "CD", has_next_page=True
-    )
 
 
 @mark.asyncio
 async def test_respects_first_and_after_with_long_first():
-    await check('first: 10, after: "{}"'.format(cursor_for("B")), "CDE")
+    await check(f'first: 10, after: "{cursor_for("B")}"', "CDE")
 
 
 @mark.asyncio
 async def test_respects_last_and_before():
-    await check(
+    await check(f'last: 2, before: "{cursor_for("D")}"', "BC", has_previous_page=True)
-        'last: 2, before: "{}"'.format(cursor_for("D")), "BC", has_previous_page=True
-    )
 
 
 @mark.asyncio
 async def test_respects_last_and_before_with_long_last():
-    await check('last: 10, before: "{}"'.format(cursor_for("D")), "ABC")
+    await check(f'last: 10, before: "{cursor_for("D")}"', "ABC")
 
 
 @mark.asyncio
 async def test_respects_first_and_after_and_before_too_few():
     await check(
-        'first: 2, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
+        f'first: 2, after: "{cursor_for("A")}", before: "{cursor_for("E")}"',
         "BC",
         has_next_page=True,
     )
@@ -168,23 +163,21 @@ async def test_respects_first_and_after_and_before_too_few():
 @mark.asyncio
 async def test_respects_first_and_after_and_before_too_many():
     await check(
-        'first: 4, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
+        f'first: 4, after: "{cursor_for("A")}", before: "{cursor_for("E")}"', "BCD"
-        "BCD",
     )
 
 
 @mark.asyncio
 async def test_respects_first_and_after_and_before_exactly_right():
     await check(
-        'first: 3, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
+        f'first: 3, after: "{cursor_for("A")}", before: "{cursor_for("E")}"', "BCD"
-        "BCD",
     )
 
 
 @mark.asyncio
 async def test_respects_last_and_after_and_before_too_few():
     await check(
-        'last: 2, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
+        f'last: 2, after: "{cursor_for("A")}", before: "{cursor_for("E")}"',
         "CD",
         has_previous_page=True,
     )
@@ -193,16 +186,14 @@ async def test_respects_last_and_after_and_before_too_few():
 @mark.asyncio
 async def test_respects_last_and_after_and_before_too_many():
     await check(
-        'last: 4, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
+        f'last: 4, after: "{cursor_for("A")}", before: "{cursor_for("E")}"', "BCD"
-        "BCD",
     )
 
 
 @mark.asyncio
 async def test_respects_last_and_after_and_before_exactly_right():
     await check(
-        'last: 3, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
+        f'last: 3, after: "{cursor_for("A")}", before: "{cursor_for("E")}"', "BCD"
-        "BCD",
     )
 
 
@@ -219,9 +210,7 @@ async def test_returns_all_elements_if_cursors_are_invalid():
 @mark.asyncio
 async def test_returns_all_elements_if_cursors_are_on_the_outside():
     await check(
-        'before: "{}" after: "{}"'.format(
+        f'before: "{base64("arrayconnection:%s" % 6)}" after: "{base64("arrayconnection:%s" % -1)}"',
-            base64("arrayconnection:%s" % 6), base64("arrayconnection:%s" % -1)
-        ),
         "ABCDE",
     )
 
@@ -229,9 +218,7 @@ async def test_returns_all_elements_if_cursors_are_on_the_outside():
 @mark.asyncio
 async def test_returns_no_elements_if_cursors_cross():
     await check(
-        'before: "{}" after: "{}"'.format(
+        f'before: "{base64("arrayconnection:%s" % 2)}" after: "{base64("arrayconnection:%s" % 4)}"',
-            base64("arrayconnection:%s" % 2), base64("arrayconnection:%s" % 4)
-        ),
         "",
     )
 

graphene/relay/tests/test_custom_global_id.py

@@ -0,0 +1,325 @@
+import re
+from uuid import uuid4
+
+from graphql import graphql_sync
+
+from ..id_type import BaseGlobalIDType, SimpleGlobalIDType, UUIDGlobalIDType
+from ..node import Node
+from ...types import Int, ObjectType, Schema, String
+
+
+class TestUUIDGlobalID:
+    def setup_method(self):
+        self.user_list = [
+            {"id": uuid4(), "name": "First"},
+            {"id": uuid4(), "name": "Second"},
+            {"id": uuid4(), "name": "Third"},
+            {"id": uuid4(), "name": "Fourth"},
+        ]
+        self.users = {user["id"]: user for user in self.user_list}
+
+        class CustomNode(Node):
+            class Meta:
+                global_id_type = UUIDGlobalIDType
+
+        class User(ObjectType):
+            class Meta:
+                interfaces = [CustomNode]
+
+            name = String()
+
+            @classmethod
+            def get_node(cls, _type, _id):
+                return self.users[_id]
+
+        class RootQuery(ObjectType):
+            user = CustomNode.Field(User)
+
+        self.schema = Schema(query=RootQuery, types=[User])
+        self.graphql_schema = self.schema.graphql_schema
+
+    def test_str_schema_correct(self):
+        """
+        Check that the schema has the expected and custom node interface and user type and that they both use UUIDs
+        """
+        parsed = re.findall(r"(.+) \{\n\s*([\w\W]*?)\n\}", str(self.schema))
+        types = [t for t, f in parsed]
+        fields = [f for t, f in parsed]
+        custom_node_interface = "interface CustomNode"
+        assert custom_node_interface in types
+        assert (
+            '"""The ID of the object"""\n  id: UUID!'
+            == fields[types.index(custom_node_interface)]
+        )
+        user_type = "type User implements CustomNode"
+        assert user_type in types
+        assert (
+            '"""The ID of the object"""\n  id: UUID!\n  name: String'
+            == fields[types.index(user_type)]
+        )
+
+    def test_get_by_id(self):
+        query = """query userById($id: UUID!) {
+            user(id: $id) {
+                id
+                name
+            }
+        }"""
+        # UUID need to be converted to string for serialization
+        result = graphql_sync(
+            self.graphql_schema,
+            query,
+            variable_values={"id": str(self.user_list[0]["id"])},
+        )
+        assert not result.errors
+        assert result.data["user"]["id"] == str(self.user_list[0]["id"])
+        assert result.data["user"]["name"] == self.user_list[0]["name"]
+
+
+class TestSimpleGlobalID:
+    def setup_method(self):
+        self.user_list = [
+            {"id": "my global primary key in clear 1", "name": "First"},
+            {"id": "my global primary key in clear 2", "name": "Second"},
+            {"id": "my global primary key in clear 3", "name": "Third"},
+            {"id": "my global primary key in clear 4", "name": "Fourth"},
+        ]
+        self.users = {user["id"]: user for user in self.user_list}
+
+        class CustomNode(Node):
+            class Meta:
+                global_id_type = SimpleGlobalIDType
+
+        class User(ObjectType):
+            class Meta:
+                interfaces = [CustomNode]
+
+            name = String()
+
+            @classmethod
+            def get_node(cls, _type, _id):
+                return self.users[_id]
+
+        class RootQuery(ObjectType):
+            user = CustomNode.Field(User)
+
+        self.schema = Schema(query=RootQuery, types=[User])
+        self.graphql_schema = self.schema.graphql_schema
+
+    def test_str_schema_correct(self):
+        """
+        Check that the schema has the expected and custom node interface and user type and that they both use UUIDs
+        """
+        parsed = re.findall(r"(.+) \{\n\s*([\w\W]*?)\n\}", str(self.schema))
+        types = [t for t, f in parsed]
+        fields = [f for t, f in parsed]
+        custom_node_interface = "interface CustomNode"
+        assert custom_node_interface in types
+        assert (
+            '"""The ID of the object"""\n  id: ID!'
+            == fields[types.index(custom_node_interface)]
+        )
+        user_type = "type User implements CustomNode"
+        assert user_type in types
+        assert (
+            '"""The ID of the object"""\n  id: ID!\n  name: String'
+            == fields[types.index(user_type)]
+        )
+
+    def test_get_by_id(self):
+        query = """query {
+            user(id: "my global primary key in clear 3") {
+                id
+                name
+            }
+        }"""
+        result = graphql_sync(self.graphql_schema, query)
+        assert not result.errors
+        assert result.data["user"]["id"] == self.user_list[2]["id"]
+        assert result.data["user"]["name"] == self.user_list[2]["name"]
+
+
+class TestCustomGlobalID:
+    def setup_method(self):
+        self.user_list = [
+            {"id": 1, "name": "First"},
+            {"id": 2, "name": "Second"},
+            {"id": 3, "name": "Third"},
+            {"id": 4, "name": "Fourth"},
+        ]
+        self.users = {user["id"]: user for user in self.user_list}
+
+        class CustomGlobalIDType(BaseGlobalIDType):
+            """
+            Global id that is simply and integer in clear.
+            """
+
+            graphene_type = Int
+
+            @classmethod
+            def resolve_global_id(cls, info, global_id):
+                _type = info.return_type.graphene_type._meta.name
+                return _type, global_id
+
+            @classmethod
+            def to_global_id(cls, _type, _id):
+                return _id
+
+        class CustomNode(Node):
+            class Meta:
+                global_id_type = CustomGlobalIDType
+
+        class User(ObjectType):
+            class Meta:
+                interfaces = [CustomNode]
+
+            name = String()
+
+            @classmethod
+            def get_node(cls, _type, _id):
+                return self.users[_id]
+
+        class RootQuery(ObjectType):
+            user = CustomNode.Field(User)
+
+        self.schema = Schema(query=RootQuery, types=[User])
+        self.graphql_schema = self.schema.graphql_schema
+
+    def test_str_schema_correct(self):
+        """
+        Check that the schema has the expected and custom node interface and user type and that they both use UUIDs
+        """
+        parsed = re.findall(r"(.+) \{\n\s*([\w\W]*?)\n\}", str(self.schema))
+        types = [t for t, f in parsed]
+        fields = [f for t, f in parsed]
+        custom_node_interface = "interface CustomNode"
+        assert custom_node_interface in types
+        assert (
+            '"""The ID of the object"""\n  id: Int!'
+            == fields[types.index(custom_node_interface)]
+        )
+        user_type = "type User implements CustomNode"
+        assert user_type in types
+        assert (
+            '"""The ID of the object"""\n  id: Int!\n  name: String'
+            == fields[types.index(user_type)]
+        )
+
+    def test_get_by_id(self):
+        query = """query {
+            user(id: 2) {
+                id
+                name
+            }
+        }"""
+        result = graphql_sync(self.graphql_schema, query)
+        assert not result.errors
+        assert result.data["user"]["id"] == self.user_list[1]["id"]
+        assert result.data["user"]["name"] == self.user_list[1]["name"]
+
+
+class TestIncompleteCustomGlobalID:
+    def setup_method(self):
+        self.user_list = [
+            {"id": 1, "name": "First"},
+            {"id": 2, "name": "Second"},
+            {"id": 3, "name": "Third"},
+            {"id": 4, "name": "Fourth"},
+        ]
+        self.users = {user["id"]: user for user in self.user_list}
+
+    def test_must_define_to_global_id(self):
+        """
+        Test that if the `to_global_id` method is not defined, we can query the object, but we can't request its ID.
+        """
+
+        class CustomGlobalIDType(BaseGlobalIDType):
+            graphene_type = Int
+
+            @classmethod
+            def resolve_global_id(cls, info, global_id):
+                _type = info.return_type.graphene_type._meta.name
+                return _type, global_id
+
+        class CustomNode(Node):
+            class Meta:
+                global_id_type = CustomGlobalIDType
+
+        class User(ObjectType):
+            class Meta:
+                interfaces = [CustomNode]
+
+            name = String()
+
+            @classmethod
+            def get_node(cls, _type, _id):
+                return self.users[_id]
+
+        class RootQuery(ObjectType):
+            user = CustomNode.Field(User)
+
+        self.schema = Schema(query=RootQuery, types=[User])
+        self.graphql_schema = self.schema.graphql_schema
+
+        query = """query {
+            user(id: 2) {
+                name
+            }
+        }"""
+        result = graphql_sync(self.graphql_schema, query)
+        assert not result.errors
+        assert result.data["user"]["name"] == self.user_list[1]["name"]
+
+        query = """query {
+            user(id: 2) {
+                id
+                name
+            }
+        }"""
+        result = graphql_sync(self.graphql_schema, query)
+        assert result.errors is not None
+        assert len(result.errors) == 1
+        assert result.errors[0].path == ["user", "id"]
+
+    def test_must_define_resolve_global_id(self):
+        """
+        Test that if the `resolve_global_id` method is not defined, we can't query the object by ID.
+        """
+
+        class CustomGlobalIDType(BaseGlobalIDType):
+            graphene_type = Int
+
+            @classmethod
+            def to_global_id(cls, _type, _id):
+                return _id
+
+        class CustomNode(Node):
+            class Meta:
+                global_id_type = CustomGlobalIDType
+
+        class User(ObjectType):
+            class Meta:
+                interfaces = [CustomNode]
+
+            name = String()
+
+            @classmethod
+            def get_node(cls, _type, _id):
+                return self.users[_id]
+
+        class RootQuery(ObjectType):
+            user = CustomNode.Field(User)
+
+        self.schema = Schema(query=RootQuery, types=[User])
+        self.graphql_schema = self.schema.graphql_schema
+
+        query = """query {
+            user(id: 2) {
+                id
+                name
+            }
+        }"""
+        result = graphql_sync(self.graphql_schema, query)
+        assert result.errors is not None
+        assert len(result.errors) == 1
+        assert result.errors[0].path == ["user"]

graphene/relay/tests/test_global_id.py

@@ -45,7 +45,7 @@ def test_global_id_allows_overriding_of_node_and_required():
 def test_global_id_defaults_to_info_parent_type():
     my_id = "1"
     gid = GlobalID()
-    id_resolver = gid.get_resolver(lambda *_: my_id)
+    id_resolver = gid.wrap_resolve(lambda *_: my_id)
     my_global_id = id_resolver(None, Info(User))
     assert my_global_id == to_global_id(User._meta.name, my_id)
 
@@ -53,6 +53,6 @@ def test_global_id_defaults_to_info_parent_type():
 def test_global_id_allows_setting_customer_parent_type():
     my_id = "1"
     gid = GlobalID(parent_type=User)
-    id_resolver = gid.get_resolver(lambda *_: my_id)
+    id_resolver = gid.wrap_resolve(lambda *_: my_id)
     my_global_id = id_resolver(None, None)
     assert my_global_id == to_global_id(User._meta.name, my_id)

graphene/relay/tests/test_mutation_async.py

@@ -3,6 +3,7 @@ from pytest import mark
 from graphene.types import ID, Field, ObjectType, Schema
 from graphene.types.scalars import String
 from graphene.relay.mutation import ClientIDMutation
+from graphene.test import Client
 
 
 class SharedFields(object):
@@ -61,24 +62,27 @@ class Mutation(ObjectType):
 
 
 schema = Schema(query=RootQuery, mutation=Mutation)
+client = Client(schema)
 
 
 @mark.asyncio
 async def test_node_query_promise():
-    executed = await schema.execute_async(
+    executed = await client.execute_async(
         'mutation a { sayPromise(input: {what:"hello", clientMutationId:"1"}) { phrase } }'
     )
-    assert not executed.errors
+    assert isinstance(executed, dict)
-    assert executed.data == {"sayPromise": {"phrase": "hello"}}
+    assert "errors" not in executed
+    assert executed["data"] == {"sayPromise": {"phrase": "hello"}}
 
 
 @mark.asyncio
 async def test_edge_query():
-    executed = await schema.execute_async(
+    executed = await client.execute_async(
         'mutation a { other(input: {clientMutationId:"1"}) { clientMutationId, myNodeEdge { cursor node { name }} } }'
     )
-    assert not executed.errors
+    assert isinstance(executed, dict)
-    assert dict(executed.data) == {
+    assert "errors" not in executed
+    assert executed["data"] == {
         "other": {
             "clientMutationId": "1",
             "myNodeEdge": {"cursor": "1", "node": {"name": "name"}},

graphene/relay/tests/test_node.py

@@ -1,14 +1,13 @@
 import re
-from graphql_relay import to_global_id
+from textwrap import dedent
 
-from graphql.pyutils import dedent
+from graphql_relay import to_global_id
 
 from ...types import ObjectType, Schema, String
 from ..node import Node, is_node
 
 
 class SharedNodeFields:
-
     shared = String()
     something_else = String()
 
@@ -55,6 +54,7 @@ def test_node_good():
     assert "id" in MyNode._meta.fields
     assert is_node(MyNode)
     assert not is_node(object)
+    assert not is_node("node")
 
 
 def test_node_query():
@@ -171,8 +171,10 @@ def test_node_field_only_lazy_type_wrong():
 
 
 def test_str_schema():
-    assert str(schema) == dedent(
+    assert (
-        '''
+        str(schema).strip()
+        == dedent(
+            '''
         schema {
           query: RootQuery
         }
@@ -183,6 +185,12 @@ def test_str_schema():
           name: String
         }
 
+        """An object with an ID"""
+        interface Node {
+          """The ID of the object"""
+          id: ID!
+        }
+
         type MyOtherNode implements Node {
           """The ID of the object"""
           id: ID!
@@ -191,12 +199,6 @@ def test_str_schema():
           extraField: String
         }
 
-        """An object with an ID"""
-        interface Node {
-          """The ID of the object"""
-          id: ID!
-        }
-
         type RootQuery {
           first: String
           node(
@@ -213,4 +215,5 @@ def test_str_schema():
           ): MyNode
         }
         '''
+        ).strip()
     )

graphene/relay/tests/test_node_custom.py

@@ -1,5 +1,6 @@
+from textwrap import dedent
+
 from graphql import graphql_sync
-from graphql.pyutils import dedent
 
 from ...types import Interface, ObjectType, Schema
 from ...types.scalars import Int, String
@@ -11,7 +12,7 @@ class CustomNode(Node):
         name = "Node"
 
     @staticmethod
-    def to_global_id(type, id):
+    def to_global_id(type_, id):
         return id
 
     @staticmethod
@@ -53,15 +54,20 @@ graphql_schema = schema.graphql_schema
 
 
 def test_str_schema_correct():
-    assert str(schema) == dedent(
+    assert (
-        '''
+        str(schema).strip()
+        == dedent(
+            '''
         schema {
           query: RootQuery
         }
 
-        interface BasePhoto {
+        type User implements Node {
-          """The width of the photo in pixels"""
+          """The ID of the object"""
-          width: Int
+          id: ID!
+
+          """The full name of the user"""
+          name: String
         }
 
         interface Node {
@@ -77,21 +83,19 @@ def test_str_schema_correct():
           width: Int
         }
 
+        interface BasePhoto {
+          """The width of the photo in pixels"""
+          width: Int
+        }
+
         type RootQuery {
           node(
             """The ID of the object"""
             id: ID!
           ): Node
         }
-
-        type User implements Node {
-          """The ID of the object"""
-          id: ID!
-
-          """The full name of the user"""
-          name: String
-        }
         '''
+        ).strip()
     )
 
 

graphene/test/__init__.py

@@ -1,5 +1,3 @@
-from promise import Promise, is_thenable
-from graphql.error import format_error as format_graphql_error
 from graphql.error import GraphQLError
 
 from graphene.types.schema import Schema
@@ -7,7 +5,7 @@ from graphene.types.schema import Schema
 
 def default_format_error(error):
     if isinstance(error, GraphQLError):
-        return format_graphql_error(error)
+        return error.formatted
     return {"message": str(error)}
 
 
@@ -32,7 +30,10 @@ class Client:
 
     def execute(self, *args, **kwargs):
         executed = self.schema.execute(*args, **dict(self.execute_options, **kwargs))
-        if is_thenable(executed):
+        return self.format_result(executed)
-            return Promise.resolve(executed).then(self.format_result)
+
-
+    async def execute_async(self, *args, **kwargs):
+        executed = await self.schema.execute_async(
+            *args, **dict(self.execute_options, **kwargs)
+        )
         return self.format_result(executed)

graphene/tests/issues/test_1293.py

@@ -0,0 +1,41 @@
+# https://github.com/graphql-python/graphene/issues/1293
+
+from datetime import datetime, timezone
+
+import graphene
+from graphql.utilities import print_schema
+
+
+class Filters(graphene.InputObjectType):
+    datetime_after = graphene.DateTime(
+        required=False,
+        default_value=datetime.fromtimestamp(1434549820.776, timezone.utc),
+    )
+    datetime_before = graphene.DateTime(
+        required=False,
+        default_value=datetime.fromtimestamp(1444549820.776, timezone.utc),
+    )
+
+
+class SetDatetime(graphene.Mutation):
+    class Arguments:
+        filters = Filters(required=True)
+
+    ok = graphene.Boolean()
+
+    def mutate(root, info, filters):
+        return SetDatetime(ok=True)
+
+
+class Query(graphene.ObjectType):
+    goodbye = graphene.String()
+
+
+class Mutations(graphene.ObjectType):
+    set_datetime = SetDatetime.Field()
+
+
+def test_schema_printable_with_default_datetime_value():
+    schema = graphene.Schema(query=Query, mutation=Mutations)
+    schema_str = print_schema(schema.graphql_schema)
+    assert schema_str, "empty schema printed"

graphene/tests/issues/test_1394.py

@@ -0,0 +1,36 @@
+from ...types import ObjectType, Schema, String, NonNull
+
+
+class Query(ObjectType):
+    hello = String(input=NonNull(String))
+
+    def resolve_hello(self, info, input):
+        if input == "nothing":
+            return None
+        return f"Hello {input}!"
+
+
+schema = Schema(query=Query)
+
+
+def test_required_input_provided():
+    """
+    Test that a required argument works when provided.
+    """
+    input_value = "Potato"
+    result = schema.execute('{ hello(input: "%s") }' % input_value)
+    assert not result.errors
+    assert result.data == {"hello": "Hello Potato!"}
+
+
+def test_required_input_missing():
+    """
+    Test that a required argument raised an error if not provided.
+    """
+    result = schema.execute("{ hello }")
+    assert result.errors
+    assert len(result.errors) == 1
+    assert (
+        result.errors[0].message
+        == "Field 'hello' argument 'input' of type 'String!' is required, but it was not provided."
+    )

graphene/tests/issues/test_1419.py

@@ -0,0 +1,53 @@
+import pytest
+
+from ...types.base64 import Base64
+from ...types.datetime import Date, DateTime
+from ...types.decimal import Decimal
+from ...types.generic import GenericScalar
+from ...types.json import JSONString
+from ...types.objecttype import ObjectType
+from ...types.scalars import ID, BigInt, Boolean, Float, Int, String
+from ...types.schema import Schema
+from ...types.uuid import UUID
+
+
+@pytest.mark.parametrize(
+    "input_type,input_value",
+    [
+        (Date, '"2022-02-02"'),
+        (GenericScalar, '"foo"'),
+        (Int, "1"),
+        (BigInt, "12345678901234567890"),
+        (Float, "1.1"),
+        (String, '"foo"'),
+        (Boolean, "true"),
+        (ID, "1"),
+        (DateTime, '"2022-02-02T11:11:11"'),
+        (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
+        (Decimal, '"1.1"'),
+        (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
+        (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
+    ],
+)
+def test_parse_literal_with_variables(input_type, input_value):
+    # input_b needs to be evaluated as literal while the variable dict for
+    # input_a is passed along.
+
+    class Query(ObjectType):
+        generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())
+
+        def resolve_generic(self, info, input_a=None, input_b=None):
+            return input
+
+    schema = Schema(query=Query)
+
+    query = f"""
+        query Test($a: GenericScalar){{
+            generic(inputA: $a, inputB: {input_value})
+        }}
+    """
+    result = schema.execute(
+        query,
+        variables={"a": "bar"},
+    )
+    assert not result.errors

graphene/tests/issues/test_356.py

@@ -27,7 +27,7 @@ def test_issue():
         graphene.Schema(query=Query)
 
     assert str(exc_info.value) == (
-        "Query fields cannot be resolved:"
+        "Query fields cannot be resolved."
         " IterableConnectionField type has to be a subclass of Connection."
         ' Received "MyUnion".'
     )

graphene/tests/issues/test_881.py

@@ -0,0 +1,27 @@
+import pickle
+
+from ...types.enum import Enum
+
+
+class PickleEnum(Enum):
+    # is defined outside of test because pickle unable to dump class inside ot pytest function
+    A = "a"
+    B = 1
+
+
+def test_enums_pickling():
+    a = PickleEnum.A
+    pickled = pickle.dumps(a)
+    restored = pickle.loads(pickled)
+    assert type(a) is type(restored)
+    assert a == restored
+    assert a.value == restored.value
+    assert a.name == restored.name
+
+    b = PickleEnum.B
+    pickled = pickle.dumps(b)
+    restored = pickle.loads(pickled)
+    assert type(a) is type(restored)
+    assert b == restored
+    assert b.value == restored.value
+    assert b.name == restored.name

graphene/types/__init__.py

@@ -1,52 +1,53 @@
-# flake8: noqa
 from graphql import GraphQLResolveInfo as ResolveInfo
 
-from .objecttype import ObjectType
+from .argument import Argument
-from .interface import Interface
+from .base64 import Base64
-from .mutation import Mutation
+from .context import Context
-from .scalars import Scalar, String, ID, Int, Float, Boolean
 from .datetime import Date, DateTime, Time
 from .decimal import Decimal
-from .json import JSONString
+from .dynamic import Dynamic
-from .uuid import UUID
-from .schema import Schema
-from .structures import List, NonNull
 from .enum import Enum
 from .field import Field
 from .inputfield import InputField
-from .argument import Argument
 from .inputobjecttype import InputObjectType
-from .dynamic import Dynamic
+from .interface import Interface
+from .json import JSONString
+from .mutation import Mutation
+from .objecttype import ObjectType
+from .scalars import ID, BigInt, Boolean, Float, Int, Scalar, String
+from .schema import Schema
+from .structures import List, NonNull
 from .union import Union
-from .context import Context
+from .uuid import UUID
-
 
 __all__ = [
-    "ObjectType",
+    "Argument",
-    "InputObjectType",
+    "Base64",
-    "Interface",
+    "BigInt",
-    "Mutation",
+    "Boolean",
-    "Enum",
+    "Context",
-    "Field",
-    "InputField",
-    "Schema",
-    "Scalar",
-    "String",
-    "ID",
-    "Int",
-    "Float",
     "Date",
     "DateTime",
-    "Time",
     "Decimal",
-    "JSONString",
-    "UUID",
-    "Boolean",
-    "List",
-    "NonNull",
-    "Argument",
     "Dynamic",
-    "Union",
+    "Enum",
-    "Context",
+    "Field",
+    "Float",
+    "ID",
+    "InputField",
+    "InputObjectType",
+    "Int",
+    "Interface",
+    "JSONString",
+    "List",
+    "Mutation",
+    "NonNull",
+    "ObjectType",
     "ResolveInfo",
+    "Scalar",
+    "Schema",
+    "String",
+    "Time",
+    "UUID",
+    "Union",
 ]

graphene/types/argument.py

@@ -1,4 +1,5 @@
 from itertools import chain
+from graphql import Undefined
 
 from .dynamic import Dynamic
 from .mountedtype import MountedType
@@ -30,18 +31,22 @@ class Argument(MountedType):
         type (class for a graphene.UnmountedType): must be a class (not an instance) of an
             unmounted graphene type (ex. scalar or object) which is used for the type of this
             argument in the GraphQL schema.
-        required (bool): indicates this argument as not null in the graphql schema. Same behavior
+        required (optional, bool): indicates this argument as not null in the graphql schema. Same behavior
             as graphene.NonNull. Default False.
-        name (str): the name of the GraphQL argument. Defaults to parameter name.
+        name (optional, str): the name of the GraphQL argument. Defaults to parameter name.
-        description (str): the description of the GraphQL argument in the schema.
+        description (optional, str): the description of the GraphQL argument in the schema.
-        default_value (Any): The value to be provided if the user does not set this argument in
+        default_value (optional, Any): The value to be provided if the user does not set this argument in
             the operation.
+        deprecation_reason (optional, str): Setting this value indicates that the argument is
+            depreciated and may provide instruction or reason on how for clients to proceed. Cannot be
+            set if the argument is required (see spec).
     """
 
     def __init__(
         self,
-        type,
+        type_,
-        default_value=None,
+        default_value=Undefined,
+        deprecation_reason=None,
         description=None,
         name=None,
         required=False,
@@ -50,12 +55,16 @@ class Argument(MountedType):
         super(Argument, self).__init__(_creation_counter=_creation_counter)
 
         if required:
-            type = NonNull(type)
+            assert (
+                deprecation_reason is None
+            ), f"Argument {name} is required, cannot deprecate it."
+            type_ = NonNull(type_)
 
         self.name = name
-        self._type = type
+        self._type = type_
         self.default_value = default_value
         self.description = description
+        self.deprecation_reason = deprecation_reason
 
     @property
     def type(self):
@@ -67,6 +76,7 @@ class Argument(MountedType):
             and self.type == other.type
             and self.default_value == other.default_value
             and self.description == other.description
+            and self.deprecation_reason == other.deprecation_reason
         )
 
 
@@ -94,18 +104,17 @@ def to_arguments(args, extra_args=None):
 
         if isinstance(arg, (InputField, Field)):
             raise ValueError(
-                "Expected {} to be Argument, but received {}. Try using Argument({}).".format(
+                f"Expected {default_name} to be Argument, "
-                    default_name, type(arg).__name__, arg.type
+                f"but received {type(arg).__name__}. Try using Argument({arg.type})."
-                )
             )
 
         if not isinstance(arg, Argument):
-            raise ValueError('Unknown argument "{}".'.format(default_name))
+            raise ValueError(f'Unknown argument "{default_name}".')
 
         arg_name = default_name or arg.name
         assert (
             arg_name not in arguments
-        ), 'More than one Argument have same name "{}".'.format(arg_name)
+        ), f'More than one Argument have same name "{arg_name}".'
         arguments[arg_name] = arg
 
     return arguments

graphene/types/base.py

@@ -1,17 +1,17 @@
-from typing import Type
+from typing import Type, Optional
 
-from ..utils.subclass_with_meta import SubclassWithMeta
+from ..utils.subclass_with_meta import SubclassWithMeta, SubclassWithMeta_Meta
 from ..utils.trim_docstring import trim_docstring
 
 
 class BaseOptions:
-    name = None  # type: str
+    name: Optional[str] = None
-    description = None  # type: str
+    description: Optional[str] = None
 
-    _frozen = False  # type: bool
+    _frozen: bool = False
 
-    def __init__(self, class_type):
+    def __init__(self, class_type: Type):
-        self.class_type = class_type  # type: Type
+        self.class_type: Type = class_type
 
     def freeze(self):
         self._frozen = True
@@ -20,10 +20,13 @@ class BaseOptions:
         if not self._frozen:
             super(BaseOptions, self).__setattr__(name, value)
         else:
-            raise Exception("Can't modify frozen Options {}".format(self))
+            raise Exception(f"Can't modify frozen Options {self}")
 
     def __repr__(self):
-        return "<{} name={}>".format(self.__class__.__name__, repr(self.name))
+        return f"<{self.__class__.__name__} name={repr(self.name)}>"
+
+
+BaseTypeMeta = SubclassWithMeta_Meta
 
 
 class BaseType(SubclassWithMeta):
@@ -35,7 +38,7 @@ class BaseType(SubclassWithMeta):
     def __init_subclass_with_meta__(
         cls, name=None, description=None, _meta=None, **_kwargs
     ):
-        assert "_meta" not in cls.__dict__, "Can't assign directly meta"
+        assert "_meta" not in cls.__dict__, "Can't assign meta directly"
         if not _meta:
             return
         _meta.name = name or cls.__name__

graphene/types/base64.py

@@ -0,0 +1,43 @@
+from binascii import Error as _Error
+from base64 import b64decode, b64encode
+
+from graphql.error import GraphQLError
+from graphql.language import StringValueNode, print_ast
+
+from .scalars import Scalar
+
+
+class Base64(Scalar):
+    """
+    The `Base64` scalar type represents a base64-encoded String.
+    """
+
+    @staticmethod
+    def serialize(value):
+        if not isinstance(value, bytes):
+            if isinstance(value, str):
+                value = value.encode("utf-8")
+            else:
+                value = str(value).encode("utf-8")
+        return b64encode(value).decode("utf-8")
+
+    @classmethod
+    def parse_literal(cls, node, _variables=None):
+        if not isinstance(node, StringValueNode):
+            raise GraphQLError(
+                f"Base64 cannot represent non-string value: {print_ast(node)}"
+            )
+        return cls.parse_value(node.value)
+
+    @staticmethod
+    def parse_value(value):
+        if not isinstance(value, bytes):
+            if not isinstance(value, str):
+                raise GraphQLError(
+                    f"Base64 cannot represent non-string value: {repr(value)}"
+                )
+            value = value.encode("utf-8")
+        try:
+            return b64decode(value, validate=True).decode("utf-8")
+        except _Error:
+            raise GraphQLError(f"Base64 cannot decode value: {repr(value)}")

graphene/types/datetime.py

@@ -1,10 +1,9 @@
-from __future__ import absolute_import
-
 import datetime
 
-from aniso8601 import parse_date, parse_datetime, parse_time
+from dateutil.parser import isoparse
-from graphql import Undefined
+
-from graphql.language import StringValueNode
+from graphql.error import GraphQLError
+from graphql.language import StringValueNode, print_ast
 
 from .scalars import Scalar
 
@@ -20,25 +19,28 @@ class Date(Scalar):
     def serialize(date):
         if isinstance(date, datetime.datetime):
             date = date.date()
-        assert isinstance(
+        if not isinstance(date, datetime.date):
-            date, datetime.date
+            raise GraphQLError(f"Date cannot represent value: {repr(date)}")
-        ), 'Received not compatible date "{}"'.format(repr(date))
         return date.isoformat()
 
     @classmethod
-    def parse_literal(cls, node):
+    def parse_literal(cls, node, _variables=None):
-        if isinstance(node, StringValueNode):
+        if not isinstance(node, StringValueNode):
-            return cls.parse_value(node.value)
+            raise GraphQLError(
+                f"Date cannot represent non-string value: {print_ast(node)}"
+            )
+        return cls.parse_value(node.value)
 
     @staticmethod
     def parse_value(value):
+        if isinstance(value, datetime.date):
+            return value
+        if not isinstance(value, str):
+            raise GraphQLError(f"Date cannot represent non-string value: {repr(value)}")
         try:
-            if isinstance(value, datetime.date):
+            return datetime.date.fromisoformat(value)
-                return value
-            elif isinstance(value, str):
-                return parse_date(value)
         except ValueError:
-            return Undefined
+            raise GraphQLError(f"Date cannot represent value: {repr(value)}")
 
 
 class DateTime(Scalar):
@@ -50,25 +52,30 @@ class DateTime(Scalar):
 
     @staticmethod
     def serialize(dt):
-        assert isinstance(
+        if not isinstance(dt, (datetime.datetime, datetime.date)):
-            dt, (datetime.datetime, datetime.date)
+            raise GraphQLError(f"DateTime cannot represent value: {repr(dt)}")
-        ), 'Received not compatible datetime "{}"'.format(repr(dt))
         return dt.isoformat()
 
     @classmethod
-    def parse_literal(cls, node):
+    def parse_literal(cls, node, _variables=None):
-        if isinstance(node, StringValueNode):
+        if not isinstance(node, StringValueNode):
-            return cls.parse_value(node.value)
+            raise GraphQLError(
+                f"DateTime cannot represent non-string value: {print_ast(node)}"
+            )
+        return cls.parse_value(node.value)
 
     @staticmethod
     def parse_value(value):
+        if isinstance(value, datetime.datetime):
+            return value
+        if not isinstance(value, str):
+            raise GraphQLError(
+                f"DateTime cannot represent non-string value: {repr(value)}"
+            )
         try:
-            if isinstance(value, datetime.datetime):
+            return isoparse(value)
-                return value
-            elif isinstance(value, str):
-                return parse_datetime(value)
         except ValueError:
-            return Undefined
+            raise GraphQLError(f"DateTime cannot represent value: {repr(value)}")
 
 
 class Time(Scalar):
@@ -80,22 +87,25 @@ class Time(Scalar):
 
     @staticmethod
     def serialize(time):
-        assert isinstance(
+        if not isinstance(time, datetime.time):
-            time, datetime.time
+            raise GraphQLError(f"Time cannot represent value: {repr(time)}")
-        ), 'Received not compatible time "{}"'.format(repr(time))
         return time.isoformat()
 
     @classmethod
-    def parse_literal(cls, node):
+    def parse_literal(cls, node, _variables=None):
-        if isinstance(node, StringValueNode):
+        if not isinstance(node, StringValueNode):
-            return cls.parse_value(node.value)
+            raise GraphQLError(
+                f"Time cannot represent non-string value: {print_ast(node)}"
+            )
+        return cls.parse_value(node.value)
 
     @classmethod
     def parse_value(cls, value):
+        if isinstance(value, datetime.time):
+            return value
+        if not isinstance(value, str):
+            raise GraphQLError(f"Time cannot represent non-string value: {repr(value)}")
         try:
-            if isinstance(value, datetime.time):
+            return datetime.time.fromisoformat(value)
-                return value
-            elif isinstance(value, str):
-                return parse_time(value)
         except ValueError:
-            return Undefined
+            raise GraphQLError(f"Time cannot represent value: {repr(value)}")

graphene/types/decimal.py

@@ -1,8 +1,7 @@
-from __future__ import absolute_import
-
 from decimal import Decimal as _Decimal
 
-from graphql.language.ast import StringValueNode
+from graphql import Undefined
+from graphql.language.ast import StringValueNode, IntValueNode
 
 from .scalars import Scalar
 
@@ -16,19 +15,20 @@ class Decimal(Scalar):
     def serialize(dec):
         if isinstance(dec, str):
             dec = _Decimal(dec)
-        assert isinstance(dec, _Decimal), 'Received not compatible Decimal "{}"'.format(
+        assert isinstance(
-            repr(dec)
+            dec, _Decimal
-        )
+        ), f'Received not compatible Decimal "{repr(dec)}"'
         return str(dec)
 
     @classmethod
-    def parse_literal(cls, node):
+    def parse_literal(cls, node, _variables=None):
-        if isinstance(node, StringValueNode):
+        if isinstance(node, (StringValueNode, IntValueNode)):
             return cls.parse_value(node.value)
+        return Undefined
 
     @staticmethod
     def parse_value(value):
         try:
             return _Decimal(value)
-        except ValueError:
+        except Exception:
-            return None
+            return Undefined

graphene/types/definitions.py

@@ -1,3 +1,5 @@
+from enum import Enum as PyEnum
+
 from graphql import (
     GraphQLEnumType,
     GraphQLInputObjectType,
@@ -18,6 +20,11 @@ class GrapheneGraphQLType:
         self.graphene_type = kwargs.pop("graphene_type")
         super(GrapheneGraphQLType, self).__init__(*args, **kwargs)
 
+    def __copy__(self):
+        result = GrapheneGraphQLType(graphene_type=self.graphene_type)
+        result.__dict__.update(self.__dict__)
+        return result
+
 
 class GrapheneInterfaceType(GrapheneGraphQLType, GraphQLInterfaceType):
     pass
@@ -36,7 +43,19 @@ class GrapheneScalarType(GrapheneGraphQLType, GraphQLScalarType):
 
 
 class GrapheneEnumType(GrapheneGraphQLType, GraphQLEnumType):
-    pass
+    def serialize(self, value):
+        if not isinstance(value, PyEnum):
+            enum = self.graphene_type._meta.enum
+            try:
+                # Try and get enum by value
+                value = enum(value)
+            except ValueError:
+                # Try and get enum by name
+                try:
+                    value = enum[value]
+                except KeyError:
+                    pass
+        return super(GrapheneEnumType, self).serialize(value)
 
 
 class GrapheneInputObjectType(GrapheneGraphQLType, GraphQLInputObjectType):

graphene/types/dynamic.py

@@ -10,10 +10,10 @@ class Dynamic(MountedType):
     the schema. So we can have lazy fields.
     """
 
-    def __init__(self, type, with_schema=False, _creation_counter=None):
+    def __init__(self, type_, with_schema=False, _creation_counter=None):
         super(Dynamic, self).__init__(_creation_counter=_creation_counter)
-        assert inspect.isfunction(type) or isinstance(type, partial)
+        assert inspect.isfunction(type_) or isinstance(type_, partial)
-        self.type = type
+        self.type = type_
         self.with_schema = with_schema
 
     def get_type(self, schema=None):

graphene/types/enum.py

@@ -12,6 +12,10 @@ def eq_enum(self, other):
     return self.value is other
 
 
+def hash_enum(self):
+    return hash(self.name)
+
+
 EnumType = type(PyEnum)
 
 
@@ -21,15 +25,17 @@ class EnumOptions(BaseOptions):
 
 
 class EnumMeta(SubclassWithMeta_Meta):
-    def __new__(cls, name, bases, classdict, **options):
+    def __new__(cls, name_, bases, classdict, **options):
-        enum_members = dict(classdict, __eq__=eq_enum)
+        enum_members = dict(classdict, __eq__=eq_enum, __hash__=hash_enum)
         # We remove the Meta attribute from the class to not collide
         # with the enum values.
         enum_members.pop("Meta", None)
         enum = PyEnum(cls.__name__, enum_members)
-        return SubclassWithMeta_Meta.__new__(
+        obj = SubclassWithMeta_Meta.__new__(
-            cls, name, bases, dict(classdict, __enum__=enum), **options
+            cls, name_, bases, dict(classdict, __enum__=enum), **options
         )
+        globals()[name_] = obj.__enum__
+        return obj
 
     def get(cls, value):
         return cls._meta.enum(value)
@@ -52,15 +58,19 @@ class EnumMeta(SubclassWithMeta_Meta):
         return super(EnumMeta, cls).__call__(*args, **kwargs)
         # return cls._meta.enum(*args, **kwargs)
 
-    def from_enum(cls, enum, description=None, deprecation_reason=None):  # noqa: N805
+    def __iter__(cls):
-        description = description or enum.__doc__
+        return cls._meta.enum.__iter__()
+
+    def from_enum(cls, enum, name=None, description=None, deprecation_reason=None):  # noqa: N805
+        name = name or enum.__name__
+        description = description or enum.__doc__ or "An enumeration."
         meta_dict = {
             "enum": enum,
             "description": description,
             "deprecation_reason": deprecation_reason,
         }
         meta_class = type("Meta", (object,), meta_dict)
-        return type(meta_class.enum.__name__, (Enum,), {"Meta": meta_class})
+        return type(name, (Enum,), {"Meta": meta_class})
 
 
 class Enum(UnmountedType, BaseType, metaclass=EnumMeta):

graphene/types/field.py

@@ -4,15 +4,17 @@ from functools import partial
 
 from .argument import Argument, to_arguments
 from .mountedtype import MountedType
+from .resolver import default_resolver
 from .structures import NonNull
 from .unmountedtype import UnmountedType
 from .utils import get_type
+from ..utils.deprecated import warn_deprecation
 
 base_type = type
 
 
 def source_resolver(source, root, info, **args):
-    resolved = getattr(root, source, None)
+    resolved = default_resolver(source, None, root, info, **args)
     if inspect.isfunction(resolved) or inspect.ismethod(resolved):
         return resolved()
     return resolved
@@ -39,11 +41,13 @@ class Field(MountedType):
             last_name = graphene.Field(String, description='Surname')  # explicitly mounted as Field
 
     args:
-        type (class for a graphene.UnmountedType): must be a class (not an instance) of an
+        type (class for a graphene.UnmountedType): Must be a class (not an instance) of an
             unmounted graphene type (ex. scalar or object) which is used for the type of this
-            field in the GraphQL schema.
+            field in the GraphQL schema. You can provide a dotted module import path (string)
-        args (optional, Dict[str, graphene.Argument]): arguments that can be input to the field.
+            to the class instead of the class itself (e.g. to avoid circular import issues).
-            Prefer to use **extra_args.
+        args (optional, Dict[str, graphene.Argument]): Arguments that can be input to the field.
+            Prefer to use ``**extra_args``, unless you use an argument name that clashes with one
+            of the Field arguments presented here (see :ref:`example<ResolverParamGraphQLArguments>`).
         resolver (optional, Callable): A function to get the value for a Field from the parent
             value object. If not set, the default resolver method for the schema is used.
         source (optional, str): attribute name to resolve for this field from the parent value
@@ -62,7 +66,7 @@ class Field(MountedType):
 
     def __init__(
         self,
-        type,
+        type_,
         args=None,
         resolver=None,
         source=None,
@@ -72,21 +76,21 @@ class Field(MountedType):
         required=False,
         _creation_counter=None,
         default_value=None,
-        **extra_args
+        **extra_args,
     ):
         super(Field, self).__init__(_creation_counter=_creation_counter)
-        assert not args or isinstance(args, Mapping), (
+        assert not args or isinstance(
-            'Arguments in a field have to be a mapping, received "{}".'
+            args, Mapping
-        ).format(args)
+        ), f'Arguments in a field have to be a mapping, received "{args}".'
         assert not (
             source and resolver
         ), "A Field cannot have a source and a resolver in at the same time."
-        assert not callable(default_value), (
+        assert not callable(
-            'The default value can not be a function but received "{}".'
+            default_value
-        ).format(base_type(default_value))
+        ), f'The default value can not be a function but received "{base_type(default_value)}".'
 
         if required:
-            type = NonNull(type)
+            type_ = NonNull(type_)
 
         # Check if name is actually an argument of the field
         if isinstance(name, (Argument, UnmountedType)):
@@ -99,7 +103,7 @@ class Field(MountedType):
             source = None
 
         self.name = name
-        self._type = type
+        self._type = type_
         self.args = to_arguments(args or {}, extra_args)
         if source:
             resolver = partial(source_resolver, source)
@@ -112,5 +116,24 @@ class Field(MountedType):
     def type(self):
         return get_type(self._type)
 
-    def get_resolver(self, parent_resolver):
+    get_resolver = None
+
+    def wrap_resolve(self, parent_resolver):
+        """
+        Wraps a function resolver, using the ObjectType resolve_{FIELD_NAME}
+        (parent_resolver) if the Field definition has no resolver.
+        """
+        if self.get_resolver is not None:
+            warn_deprecation(
+                "The get_resolver method is being deprecated, please rename it to wrap_resolve."
+            )
+            return self.get_resolver(parent_resolver)
+
         return self.resolver or parent_resolver
+
+    def wrap_subscribe(self, parent_subscribe):
+        """
+        Wraps a function subscribe, using the ObjectType subscribe_{FIELD_NAME}
+        (parent_subscribe) if the Field definition has no subscribe.
+        """
+        return parent_subscribe

graphene/types/generic.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from graphql.language.ast import (
     BooleanValueNode,
     FloatValueNode,
@@ -29,7 +27,7 @@ class GenericScalar(Scalar):
     parse_value = identity
 
     @staticmethod
-    def parse_literal(ast):
+    def parse_literal(ast, _variables=None):
         if isinstance(ast, (StringValueNode, BooleanValueNode)):
             return ast.value
         elif isinstance(ast, IntValueNode):

graphene/types/inputfield.py

@@ -1,4 +1,5 @@
 from graphql import Undefined
+
 from .mountedtype import MountedType
 from .structures import NonNull
 from .utils import get_type
@@ -47,20 +48,23 @@ class InputField(MountedType):
 
     def __init__(
         self,
-        type,
+        type_,
         name=None,
         default_value=Undefined,
         deprecation_reason=None,
         description=None,
         required=False,
         _creation_counter=None,
-        **extra_args
+        **extra_args,
     ):
         super(InputField, self).__init__(_creation_counter=_creation_counter)
         self.name = name
         if required:
-            type = NonNull(type)
+            assert (
-        self._type = type
+                deprecation_reason is None
+            ), f"InputField {name} is required, cannot deprecate it."
+            type_ = NonNull(type_)
+        self._type = type_
         self.deprecation_reason = deprecation_reason
         self.default_value = default_value
         self.description = description

graphene/types/inputobjecttype.py

@@ -1,11 +1,12 @@
+from typing import TYPE_CHECKING
+
 from .base import BaseOptions, BaseType
 from .inputfield import InputField
 from .unmountedtype import UnmountedType
 from .utils import yank_fields_from_attrs
 
-# For static type checking with Mypy
+# For static type checking with type checker
-MYPY = False
+if TYPE_CHECKING:
-if MYPY:
     from typing import Dict, Callable  # NOQA
 
 
@@ -14,14 +15,39 @@ class InputObjectTypeOptions(BaseOptions):
     container = None  # type: InputObjectTypeContainer
 
 
-class InputObjectTypeContainer(dict, BaseType):
+# Currently in Graphene, we get a `None` whenever we access an (optional) field that was not set in an InputObjectType
+# using the InputObjectType.<attribute> dot access syntax. This is ambiguous, because in this current (Graphene
+# historical) arrangement, we cannot distinguish between a field not being set and a field being set to None.
+# At the same time, we shouldn't break existing code that expects a `None` when accessing a field that was not set.
+_INPUT_OBJECT_TYPE_DEFAULT_VALUE = None
+
+# To mitigate this, we provide the function `set_input_object_type_default_value` to allow users to change the default
+# value returned in non-specified fields in InputObjectType to another meaningful sentinel value (e.g. Undefined)
+# if they want to. This way, we can keep code that expects a `None` working while we figure out a better solution (or
+# a well-documented breaking change) for this issue.
+
+
+def set_input_object_type_default_value(default_value):
+    """
+    Change the sentinel value returned by non-specified fields in an InputObjectType
+    Useful to differentiate between a field not being set and a field being set to None by using a sentinel value
+    (e.g. Undefined is a good sentinel value for this purpose)
+
+    This function should be called at the beginning of the app or in some other place where it is guaranteed to
+    be called before any InputObjectType is defined.
+    """
+    global _INPUT_OBJECT_TYPE_DEFAULT_VALUE
+    _INPUT_OBJECT_TYPE_DEFAULT_VALUE = default_value
+
+
+class InputObjectTypeContainer(dict, BaseType):  # type: ignore
     class Meta:
         abstract = True
 
     def __init__(self, *args, **kwargs):
         dict.__init__(self, *args, **kwargs)
         for key in self._meta.fields:
-            setattr(self, key, self.get(key, None))
+            setattr(self, key, self.get(key, _INPUT_OBJECT_TYPE_DEFAULT_VALUE))
 
     def __init_subclass__(cls, *args, **kwargs):
         pass

graphene/types/interface.py

@@ -1,15 +1,17 @@
+from typing import TYPE_CHECKING
+
 from .base import BaseOptions, BaseType
 from .field import Field
 from .utils import yank_fields_from_attrs
 
-# For static type checking with Mypy
+# For static type checking with type checker
-MYPY = False
+if TYPE_CHECKING:
-if MYPY:
+    from typing import Dict, Iterable, Type  # NOQA
-    from typing import Dict  # NOQA
 
 
 class InterfaceOptions(BaseOptions):
     fields = None  # type: Dict[str, Field]
+    interfaces = ()  # type: Iterable[Type[Interface]]
 
 
 class Interface(BaseType):
@@ -45,7 +47,7 @@ class Interface(BaseType):
     """
 
     @classmethod
-    def __init_subclass_with_meta__(cls, _meta=None, **options):
+    def __init_subclass_with_meta__(cls, _meta=None, interfaces=(), **options):
         if not _meta:
             _meta = InterfaceOptions(cls)
 
@@ -58,6 +60,9 @@ class Interface(BaseType):
         else:
             _meta.fields = fields
 
+        if not _meta.interfaces:
+            _meta.interfaces = interfaces
+
         super(Interface, cls).__init_subclass_with_meta__(_meta=_meta, **options)
 
     @classmethod

graphene/types/json.py

@@ -1,7 +1,6 @@
-from __future__ import absolute_import
-
 import json
 
+from graphql import Undefined
 from graphql.language.ast import StringValueNode
 
 from .scalars import Scalar
@@ -20,9 +19,13 @@ class JSONString(Scalar):
         return json.dumps(dt)
 
     @staticmethod
-    def parse_literal(node):
+    def parse_literal(node, _variables=None):
         if isinstance(node, StringValueNode):
-            return json.loads(node.value)
+            try:
+                return json.loads(node.value)
+            except Exception as error:
+                raise ValueError(f"Badly formed JSONString: {str(error)}")
+        return Undefined
 
     @staticmethod
     def parse_value(value):

graphene/types/mountedtype.py

@@ -8,13 +8,13 @@ class MountedType(OrderedType):
         """
         Mount the UnmountedType instance
         """
-        assert isinstance(unmounted, UnmountedType), ("{} can't mount {}").format(
+        assert isinstance(
-            cls.__name__, repr(unmounted)
+            unmounted, UnmountedType
-        )
+        ), f"{cls.__name__} can't mount {repr(unmounted)}"
 
         return cls(
             unmounted.get_type(),
             *unmounted.args,
             _creation_counter=unmounted.creation_counter,
-            **unmounted.kwargs
+            **unmounted.kwargs,
         )

graphene/types/mutation.py

@@ -1,3 +1,5 @@
+from typing import TYPE_CHECKING
+
 from ..utils.deprecated import warn_deprecation
 from ..utils.get_unbound_function import get_unbound_function
 from ..utils.props import props
@@ -6,9 +8,8 @@ from .objecttype import ObjectType, ObjectTypeOptions
 from .utils import yank_fields_from_attrs
 from .interface import Interface
 
-# For static type checking with Mypy
+# For static type checking with type checker
-MYPY = False
+if TYPE_CHECKING:
-if MYPY:
     from .argument import Argument  # NOQA
     from typing import Dict, Type, Callable, Iterable  # NOQA
 
@@ -29,21 +30,21 @@ class Mutation(ObjectType):
 
     .. code:: python
 
-        from graphene import Mutation, ObjectType, String, Boolean, Field
+        import graphene
 
-        class CreatePerson(Mutation):
+        class CreatePerson(graphene.Mutation):
             class Arguments:
-                name = String()
+                name = graphene.String()
 
-            ok = Boolean()
+            ok = graphene.Boolean()
-            person = Field(Person)
+            person = graphene.Field(Person)
 
             def mutate(parent, info, name):
                 person = Person(name=name)
                 ok = True
                 return CreatePerson(person=person, ok=ok)
 
-        class Mutation(ObjectType):
+        class Mutation(graphene.ObjectType):
             create_person = CreatePerson.Field()
 
     Meta class options (optional):
@@ -72,56 +73,44 @@ class Mutation(ObjectType):
         output=None,
         arguments=None,
         _meta=None,
-        **options
+        **options,
     ):
         if not _meta:
             _meta = MutationOptions(cls)
-
         output = output or getattr(cls, "Output", None)
         fields = {}
 
         for interface in interfaces:
-            assert issubclass(interface, Interface), (
+            assert issubclass(
-                'All interfaces of {} must be a subclass of Interface. Received "{}".'
+                interface, Interface
-            ).format(cls.__name__, interface)
+            ), f'All interfaces of {cls.__name__} must be a subclass of Interface. Received "{interface}".'
             fields.update(interface._meta.fields)
-
         if not output:
             # If output is defined, we don't need to get the fields
             fields = {}
             for base in reversed(cls.__mro__):
                 fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
             output = cls
-
         if not arguments:
             input_class = getattr(cls, "Arguments", None)
             if not input_class:
                 input_class = getattr(cls, "Input", None)
                 if input_class:
                     warn_deprecation(
-                        (
+                        f"Please use {cls.__name__}.Arguments instead of {cls.__name__}.Input."
-                            "Please use {name}.Arguments instead of {name}.Input."
+                        " Input is now only used in ClientMutationID.\n"
-                            " Input is now only used in ClientMutationID.\n"
+                        "Read more:"
-                            "Read more:"
+                        " https://github.com/graphql-python/graphene/blob/v2.0.0/UPGRADE-v2.0.md#mutation-input"
-                            " https://github.com/graphql-python/graphene/blob/v2.0.0/UPGRADE-v2.0.md#mutation-input"
-                        ).format(name=cls.__name__)
                     )
-
+            arguments = props(input_class) if input_class else {}
-            if input_class:
-                arguments = props(input_class)
-            else:
-                arguments = {}
-
         if not resolver:
             mutate = getattr(cls, "mutate", None)
             assert mutate, "All mutations must define a mutate method in it"
             resolver = get_unbound_function(mutate)
-
         if _meta.fields:
             _meta.fields.update(fields)
         else:
             _meta.fields = fields
-
         _meta.interfaces = interfaces
         _meta.output = output
         _meta.resolver = resolver
@@ -133,7 +122,7 @@ class Mutation(ObjectType):
     def Field(
         cls, name=None, description=None, deprecation_reason=None, required=False
     ):
-        """ Mount instance of mutation Field. """
+        """Mount instance of mutation Field."""
         return Field(
             cls._meta.output,
             args=cls._meta.arguments,

graphene/types/objecttype.py

@@ -1,11 +1,14 @@
-from .base import BaseOptions, BaseType
+from typing import TYPE_CHECKING
+
+from .base import BaseOptions, BaseType, BaseTypeMeta
 from .field import Field
 from .interface import Interface
 from .utils import yank_fields_from_attrs
 
-# For static type checking with Mypy
+from dataclasses import make_dataclass, field
-MYPY = False
+
-if MYPY:
+# For static type checking with type checker
+if TYPE_CHECKING:
     from typing import Dict, Iterable, Type  # NOQA
 
 
@@ -14,7 +17,38 @@ class ObjectTypeOptions(BaseOptions):
     interfaces = ()  # type: Iterable[Type[Interface]]
 
 
-class ObjectType(BaseType):
+class ObjectTypeMeta(BaseTypeMeta):
+    def __new__(cls, name_, bases, namespace, **options):
+        # Note: it's safe to pass options as keyword arguments as they are still type-checked by ObjectTypeOptions.
+
+        # We create this type, to then overload it with the dataclass attrs
+        class InterObjectType:
+            pass
+
+        base_cls = super().__new__(
+            cls, name_, (InterObjectType,) + bases, namespace, **options
+        )
+        if base_cls._meta:
+            fields = [
+                (
+                    key,
+                    "typing.Any",
+                    field(
+                        default=field_value.default_value
+                        if isinstance(field_value, Field)
+                        else None
+                    ),
+                )
+                for key, field_value in base_cls._meta.fields.items()
+            ]
+            dataclass = make_dataclass(name_, fields, bases=())
+            InterObjectType.__init__ = dataclass.__init__
+            InterObjectType.__eq__ = dataclass.__eq__
+            InterObjectType.__repr__ = dataclass.__repr__
+        return base_cls
+
+
+class ObjectType(BaseType, metaclass=ObjectTypeMeta):
     """
     Object Type Definition
 
@@ -30,7 +64,7 @@ class ObjectType(BaseType):
     Methods starting with ``resolve_<field_name>`` are bound as resolvers of the matching Field
     name. If no resolver is provided, the default resolver is used.
 
-    Ambiguous types with Interface and Union can be determined through``is_type_of`` method and
+    Ambiguous types with Interface and Union can be determined through ``is_type_of`` method and
     ``Meta.possible_types`` attribute.
 
     .. code:: python
@@ -93,32 +127,28 @@ class ObjectType(BaseType):
         possible_types=(),
         default_resolver=None,
         _meta=None,
-        **options
+        **options,
     ):
         if not _meta:
             _meta = ObjectTypeOptions(cls)
-
         fields = {}
 
         for interface in interfaces:
-            assert issubclass(interface, Interface), (
+            assert issubclass(
-                'All interfaces of {} must be a subclass of Interface. Received "{}".'
+                interface, Interface
-            ).format(cls.__name__, interface)
+            ), f'All interfaces of {cls.__name__} must be a subclass of Interface. Received "{interface}".'
             fields.update(interface._meta.fields)
-
         for base in reversed(cls.__mro__):
             fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
-
         assert not (possible_types and cls.is_type_of), (
-            "{name}.Meta.possible_types will cause type collision with {name}.is_type_of. "
+            f"{cls.__name__}.Meta.possible_types will cause type collision with {cls.__name__}.is_type_of. "
             "Please use one or other."
-        ).format(name=cls.__name__)
+        )
 
         if _meta.fields:
             _meta.fields.update(fields)
         else:
             _meta.fields = fields
-
         if not _meta.interfaces:
             _meta.interfaces = interfaces
         _meta.possible_types = possible_types
@@ -127,45 +157,3 @@ class ObjectType(BaseType):
         super(ObjectType, cls).__init_subclass_with_meta__(_meta=_meta, **options)
 
     is_type_of = None
-
-    def __init__(self, *args, **kwargs):
-        # ObjectType acting as container
-        args_len = len(args)
-        fields = self._meta.fields.items()
-        if args_len > len(fields):
-            # Daft, but matches old exception sans the err msg.
-            raise IndexError("Number of args exceeds number of fields")
-        fields_iter = iter(fields)
-
-        if not kwargs:
-            for val, (name, field) in zip(args, fields_iter):
-                setattr(self, name, val)
-        else:
-            for val, (name, field) in zip(args, fields_iter):
-                setattr(self, name, val)
-                kwargs.pop(name, None)
-
-        for name, field in fields_iter:
-            try:
-                val = kwargs.pop(
-                    name, field.default_value if isinstance(field, Field) else None
-                )
-                setattr(self, name, val)
-            except KeyError:
-                pass
-
-        if kwargs:
-            for prop in list(kwargs):
-                try:
-                    if isinstance(
-                        getattr(self.__class__, prop), property
-                    ) or prop.startswith("_"):
-                        setattr(self, prop, kwargs.pop(prop))
-                except AttributeError:
-                    pass
-            if kwargs:
-                raise TypeError(
-                    "'{}' is an invalid keyword argument for {}".format(
-                        list(kwargs)[0], self.__class__.__name__
-                    )
-                )

graphene/types/resolver.py

@@ -7,9 +7,7 @@ def dict_resolver(attname, default_value, root, info, **args):
 
 
 def dict_or_attr_resolver(attname, default_value, root, info, **args):
-    resolver = attr_resolver
+    resolver = dict_resolver if isinstance(root, dict) else attr_resolver
-    if isinstance(root, dict):
-        resolver = dict_resolver
     return resolver(attname, default_value, root, info, **args)
 
 

graphene/types/scalars.py

@@ -1,5 +1,6 @@
 from typing import Any
 
+from graphql import Undefined
 from graphql.language.ast import (
     BooleanValueNode,
     FloatValueNode,
@@ -67,19 +68,49 @@ class Int(Scalar):
             try:
                 num = int(float(value))
             except ValueError:
-                return None
+                return Undefined
         if MIN_INT <= num <= MAX_INT:
             return num
+        return Undefined
 
     serialize = coerce_int
     parse_value = coerce_int
 
     @staticmethod
-    def parse_literal(ast):
+    def parse_literal(ast, _variables=None):
         if isinstance(ast, IntValueNode):
             num = int(ast.value)
             if MIN_INT <= num <= MAX_INT:
                 return num
+        return Undefined
+
+
+class BigInt(Scalar):
+    """
+    The `BigInt` scalar type represents non-fractional whole numeric values.
+    `BigInt` is not constrained to 32-bit like the `Int` type and thus is a less
+    compatible type.
+    """
+
+    @staticmethod
+    def coerce_int(value):
+        try:
+            num = int(value)
+        except ValueError:
+            try:
+                num = int(float(value))
+            except ValueError:
+                return Undefined
+        return num
+
+    serialize = coerce_int
+    parse_value = coerce_int
+
+    @staticmethod
+    def parse_literal(ast, _variables=None):
+        if isinstance(ast, IntValueNode):
+            return int(ast.value)
+        return Undefined
 
 
 class Float(Scalar):
@@ -90,20 +121,20 @@ class Float(Scalar):
     """
 
     @staticmethod
-    def coerce_float(value):
+    def coerce_float(value: Any) -> float:
-        # type: (Any) -> float
         try:
             return float(value)
         except ValueError:
-            return None
+            return Undefined
 
     serialize = coerce_float
     parse_value = coerce_float
 
     @staticmethod
-    def parse_literal(ast):
+    def parse_literal(ast, _variables=None):
         if isinstance(ast, (FloatValueNode, IntValueNode)):
             return float(ast.value)
+        return Undefined
 
 
 class String(Scalar):
@@ -116,16 +147,17 @@ class String(Scalar):
     @staticmethod
     def coerce_string(value):
         if isinstance(value, bool):
-            return u"true" if value else u"false"
+            return "true" if value else "false"
         return str(value)
 
     serialize = coerce_string
     parse_value = coerce_string
 
     @staticmethod
-    def parse_literal(ast):
+    def parse_literal(ast, _variables=None):
         if isinstance(ast, StringValueNode):
             return ast.value
+        return Undefined
 
 
 class Boolean(Scalar):
@@ -137,9 +169,10 @@ class Boolean(Scalar):
     parse_value = bool
 
     @staticmethod
-    def parse_literal(ast):
+    def parse_literal(ast, _variables=None):
         if isinstance(ast, BooleanValueNode):
             return ast.value
+        return Undefined
 
 
 class ID(Scalar):
@@ -155,6 +188,7 @@ class ID(Scalar):
     parse_value = str
 
     @staticmethod
-    def parse_literal(ast):
+    def parse_literal(ast, _variables=None):
         if isinstance(ast, (StringValueNode, IntValueNode)):
             return ast.value
+        return Undefined

graphene/types/schema.py

@@ -1,3 +1,4 @@
+from enum import Enum as PyEnum
 import inspect
 from functools import partial
 
@@ -7,10 +8,14 @@ from graphql import (
     graphql,
     graphql_sync,
     introspection_types,
-    is_type,
+    parse,
     print_schema,
+    subscribe,
+    validate,
+    ExecutionResult,
     GraphQLArgument,
     GraphQLBoolean,
+    GraphQLError,
     GraphQLEnumValue,
     GraphQLField,
     GraphQLFloat,
@@ -22,7 +27,6 @@ from graphql import (
     GraphQLObjectType,
     GraphQLSchema,
     GraphQLString,
-    Undefined,
 )
 
 from ..utils.str_converters import to_camel_case
@@ -57,9 +61,9 @@ def assert_valid_root_type(type_):
         return
     is_graphene_objecttype = inspect.isclass(type_) and issubclass(type_, ObjectType)
     is_graphql_objecttype = isinstance(type_, GraphQLObjectType)
-    assert is_graphene_objecttype or is_graphql_objecttype, (
+    assert (
-        "Type {} is not a valid ObjectType."
+        is_graphene_objecttype or is_graphql_objecttype
-    ).format(type_)
+    ), f"Type {type_} is not a valid ObjectType."
 
 
 def is_graphene_type(type_):
@@ -71,118 +75,75 @@ def is_graphene_type(type_):
         return True
 
 
-def resolve_type(resolve_type_func, map_, type_name, root, info, _type):
-    type_ = resolve_type_func(root, info)
-
-    if not type_:
-        return_type = map_[type_name]
-        return default_type_resolver(root, info, return_type)
-
-    if inspect.isclass(type_) and issubclass(type_, ObjectType):
-        graphql_type = map_.get(type_._meta.name)
-        assert graphql_type, "Can't find type {} in schema".format(type_._meta.name)
-        assert graphql_type.graphene_type == type_, (
-            "The type {} does not match with the associated graphene type {}."
-        ).format(type_, graphql_type.graphene_type)
-        return graphql_type
-
-    return type_
-
-
 def is_type_of_from_possible_types(possible_types, root, _info):
     return isinstance(root, possible_types)
 
 
-class GrapheneGraphQLSchema(GraphQLSchema):
+# We use this resolver for subscriptions
-    """A GraphQLSchema that can deal with Graphene types as well."""
+def identity_resolve(root, info, **arguments):
+    return root
 
+
+class TypeMap(dict):
     def __init__(
         self,
         query=None,
         mutation=None,
         subscription=None,
         types=None,
-        directives=None,
         auto_camelcase=True,
     ):
         assert_valid_root_type(query)
         assert_valid_root_type(mutation)
         assert_valid_root_type(subscription)
+        if types is None:
+            types = []
+        for type_ in types:
+            assert is_graphene_type(type_)
 
         self.auto_camelcase = auto_camelcase
-        super().__init__(query, mutation, subscription, types, directives)
 
-        if query:
+        create_graphql_type = self.add_type
-            self.query_type = self.get_type(
-                query.name if isinstance(query, GraphQLObjectType) else query._meta.name
-            )
-        if mutation:
-            self.mutation_type = self.get_type(
-                mutation.name
-                if isinstance(mutation, GraphQLObjectType)
-                else mutation._meta.name
-            )
-        if subscription:
-            self.subscription_type = self.get_type(
-                subscription.name
-                if isinstance(subscription, GraphQLObjectType)
-                else subscription._meta.name
-            )
 
-    def get_graphql_type(self, _type):
+        self.query = create_graphql_type(query) if query else None
-        if not _type:
+        self.mutation = create_graphql_type(mutation) if mutation else None
-            return _type
+        self.subscription = create_graphql_type(subscription) if subscription else None
-        if is_type(_type):
+
-            return _type
+        self.types = [create_graphql_type(graphene_type) for graphene_type in types]
-        if is_graphene_type(_type):
+
-            graphql_type = self.get_type(_type._meta.name)
+    def add_type(self, graphene_type):
-            assert graphql_type, "Type {} not found in this schema.".format(
+        if inspect.isfunction(graphene_type):
-                _type._meta.name
+            graphene_type = graphene_type()
-            )
+        if isinstance(graphene_type, List):
-            assert graphql_type.graphene_type == _type
+            return GraphQLList(self.add_type(graphene_type.of_type))
+        if isinstance(graphene_type, NonNull):
+            return GraphQLNonNull(self.add_type(graphene_type.of_type))
+        try:
+            name = graphene_type._meta.name
+        except AttributeError:
+            raise TypeError(f"Expected Graphene type, but received: {graphene_type}.")
+        graphql_type = self.get(name)
+        if graphql_type:
             return graphql_type
-        raise Exception("{} is not a valid GraphQL type.".format(_type))
+        if issubclass(graphene_type, ObjectType):
-
+            graphql_type = self.create_objecttype(graphene_type)
-    # noinspection PyMethodOverriding
+        elif issubclass(graphene_type, InputObjectType):
-    def type_map_reducer(self, map_, type_):
+            graphql_type = self.create_inputobjecttype(graphene_type)
-        if not type_:
+        elif issubclass(graphene_type, Interface):
-            return map_
+            graphql_type = self.create_interface(graphene_type)
-        if inspect.isfunction(type_):
+        elif issubclass(graphene_type, Scalar):
-            type_ = type_()
+            graphql_type = self.create_scalar(graphene_type)
-        if is_graphene_type(type_):
+        elif issubclass(graphene_type, Enum):
-            return self.graphene_reducer(map_, type_)
+            graphql_type = self.create_enum(graphene_type)
-        return super().type_map_reducer(map_, type_)
+        elif issubclass(graphene_type, Union):
-
+            graphql_type = self.construct_union(graphene_type)
-    def graphene_reducer(self, map_, type_):
-        if isinstance(type_, (List, NonNull)):
-            return self.type_map_reducer(map_, type_.of_type)
-        if type_._meta.name in map_:
-            _type = map_[type_._meta.name]
-            if isinstance(_type, GrapheneGraphQLType):
-                assert _type.graphene_type == type_, (
-                    "Found different types with the same name in the schema: {}, {}."
-                ).format(_type.graphene_type, type_)
-            return map_
-
-        if issubclass(type_, ObjectType):
-            internal_type = self.construct_objecttype(map_, type_)
-        elif issubclass(type_, InputObjectType):
-            internal_type = self.construct_inputobjecttype(map_, type_)
-        elif issubclass(type_, Interface):
-            internal_type = self.construct_interface(map_, type_)
-        elif issubclass(type_, Scalar):
-            internal_type = self.construct_scalar(type_)
-        elif issubclass(type_, Enum):
-            internal_type = self.construct_enum(type_)
-        elif issubclass(type_, Union):
-            internal_type = self.construct_union(map_, type_)
         else:
-            raise Exception("Expected Graphene type, but received: {}.".format(type_))
+            raise TypeError(f"Expected Graphene type, but received: {graphene_type}.")
-
+        self[name] = graphql_type
-        return super().type_map_reducer(map_, internal_type)
+        return graphql_type
 
     @staticmethod
-    def construct_scalar(type_):
+    def create_scalar(graphene_type):
         # We have a mapping to the original GraphQL types
         # so there are no collisions.
         _scalars = {
@@ -192,138 +153,146 @@ class GrapheneGraphQLSchema(GraphQLSchema):
             Boolean: GraphQLBoolean,
             ID: GraphQLID,
         }
-        if type_ in _scalars:
+        if graphene_type in _scalars:
-            return _scalars[type_]
+            return _scalars[graphene_type]
 
         return GrapheneScalarType(
-            graphene_type=type_,
+            graphene_type=graphene_type,
-            name=type_._meta.name,
+            name=graphene_type._meta.name,
-            description=type_._meta.description,
+            description=graphene_type._meta.description,
-            serialize=getattr(type_, "serialize", None),
+            serialize=getattr(graphene_type, "serialize", None),
-            parse_value=getattr(type_, "parse_value", None),
+            parse_value=getattr(graphene_type, "parse_value", None),
-            parse_literal=getattr(type_, "parse_literal", None),
+            parse_literal=getattr(graphene_type, "parse_literal", None),
         )
 
     @staticmethod
-    def construct_enum(type_):
+    def create_enum(graphene_type):
         values = {}
-        for name, value in type_._meta.enum.__members__.items():
+        for name, value in graphene_type._meta.enum.__members__.items():
             description = getattr(value, "description", None)
-            deprecation_reason = getattr(value, "deprecation_reason", None)
+            # if the "description" attribute is an Enum, it is likely an enum member
-            if not description and callable(type_._meta.description):
+            # called description, not a description property
-                description = type_._meta.description(value)
+            if isinstance(description, PyEnum):
+                description = None
+            if not description and callable(graphene_type._meta.description):
+                description = graphene_type._meta.description(value)
 
-            if not deprecation_reason and callable(type_._meta.deprecation_reason):
+            deprecation_reason = getattr(value, "deprecation_reason", None)
-                deprecation_reason = type_._meta.deprecation_reason(value)
+            if isinstance(deprecation_reason, PyEnum):
+                deprecation_reason = None
+            if not deprecation_reason and callable(
+                graphene_type._meta.deprecation_reason
+            ):
+                deprecation_reason = graphene_type._meta.deprecation_reason(value)
 
             values[name] = GraphQLEnumValue(
-                value=value.value,
+                value=value,
                 description=description,
                 deprecation_reason=deprecation_reason,
             )
 
         type_description = (
-            type_._meta.description(None)
+            graphene_type._meta.description(None)
-            if callable(type_._meta.description)
+            if callable(graphene_type._meta.description)
-            else type_._meta.description
+            else graphene_type._meta.description
         )
 
         return GrapheneEnumType(
-            graphene_type=type_,
+            graphene_type=graphene_type,
             values=values,
-            name=type_._meta.name,
+            name=graphene_type._meta.name,
             description=type_description,
         )
 
-    def construct_objecttype(self, map_, type_):
+    def create_objecttype(self, graphene_type):
-        if type_._meta.name in map_:
+        create_graphql_type = self.add_type
-            _type = map_[type_._meta.name]
-            if isinstance(_type, GrapheneGraphQLType):
-                assert _type.graphene_type == type_, (
-                    "Found different types with the same name in the schema: {}, {}."
-                ).format(_type.graphene_type, type_)
-            return _type
 
         def interfaces():
             interfaces = []
-            for interface in type_._meta.interfaces:
+            for graphene_interface in graphene_type._meta.interfaces:
-                self.graphene_reducer(map_, interface)
+                interface = create_graphql_type(graphene_interface)
-                internal_type = map_[interface._meta.name]
+                assert interface.graphene_type == graphene_interface
-                assert internal_type.graphene_type == interface
+                interfaces.append(interface)
-                interfaces.append(internal_type)
             return interfaces
 
-        if type_._meta.possible_types:
+        if graphene_type._meta.possible_types:
             is_type_of = partial(
-                is_type_of_from_possible_types, type_._meta.possible_types
+                is_type_of_from_possible_types, graphene_type._meta.possible_types
             )
         else:
-            is_type_of = type_.is_type_of
+            is_type_of = graphene_type.is_type_of
 
         return GrapheneObjectType(
-            graphene_type=type_,
+            graphene_type=graphene_type,
-            name=type_._meta.name,
+            name=graphene_type._meta.name,
-            description=type_._meta.description,
+            description=graphene_type._meta.description,
-            fields=partial(self.construct_fields_for_type, map_, type_),
+            fields=partial(self.create_fields_for_type, graphene_type),
             is_type_of=is_type_of,
             interfaces=interfaces,
         )
 
-    def construct_interface(self, map_, type_):
+    def create_interface(self, graphene_type):
-        if type_._meta.name in map_:
+        resolve_type = (
-            _type = map_[type_._meta.name]
+            partial(
-            if isinstance(_type, GrapheneInterfaceType):
+                self.resolve_type, graphene_type.resolve_type, graphene_type._meta.name
-                assert _type.graphene_type == type_, (
-                    "Found different types with the same name in the schema: {}, {}."
-                ).format(_type.graphene_type, type_)
-            return _type
-
-        _resolve_type = None
-        if type_.resolve_type:
-            _resolve_type = partial(
-                resolve_type, type_.resolve_type, map_, type_._meta.name
             )
-        return GrapheneInterfaceType(
+            if graphene_type.resolve_type
-            graphene_type=type_,
+            else None
-            name=type_._meta.name,
-            description=type_._meta.description,
-            fields=partial(self.construct_fields_for_type, map_, type_),
-            resolve_type=_resolve_type,
         )
 
-    def construct_inputobjecttype(self, map_, type_):
+        def interfaces():
+            interfaces = []
+            for graphene_interface in graphene_type._meta.interfaces:
+                interface = self.add_type(graphene_interface)
+                assert interface.graphene_type == graphene_interface
+                interfaces.append(interface)
+            return interfaces
+
+        return GrapheneInterfaceType(
+            graphene_type=graphene_type,
+            name=graphene_type._meta.name,
+            description=graphene_type._meta.description,
+            fields=partial(self.create_fields_for_type, graphene_type),
+            interfaces=interfaces,
+            resolve_type=resolve_type,
+        )
+
+    def create_inputobjecttype(self, graphene_type):
         return GrapheneInputObjectType(
-            graphene_type=type_,
+            graphene_type=graphene_type,
-            name=type_._meta.name,
+            name=graphene_type._meta.name,
-            description=type_._meta.description,
+            description=graphene_type._meta.description,
-            out_type=type_._meta.container,
+            out_type=graphene_type._meta.container,
             fields=partial(
-                self.construct_fields_for_type, map_, type_, is_input_type=True
+                self.create_fields_for_type, graphene_type, is_input_type=True
             ),
         )
 
-    def construct_union(self, map_, type_):
+    def construct_union(self, graphene_type):
-        _resolve_type = None
+        create_graphql_type = self.add_type
-        if type_.resolve_type:
-            _resolve_type = partial(
-                resolve_type, type_.resolve_type, map_, type_._meta.name
-            )
 
         def types():
             union_types = []
-            for objecttype in type_._meta.types:
+            for graphene_objecttype in graphene_type._meta.types:
-                self.graphene_reducer(map_, objecttype)
+                object_type = create_graphql_type(graphene_objecttype)
-                internal_type = map_[objecttype._meta.name]
+                assert object_type.graphene_type == graphene_objecttype
-                assert internal_type.graphene_type == objecttype
+                union_types.append(object_type)
-                union_types.append(internal_type)
             return union_types
 
+        resolve_type = (
+            partial(
+                self.resolve_type, graphene_type.resolve_type, graphene_type._meta.name
+            )
+            if graphene_type.resolve_type
+            else None
+        )
+
         return GrapheneUnionType(
-            graphene_type=type_,
+            graphene_type=graphene_type,
-            name=type_._meta.name,
+            name=graphene_type._meta.name,
-            description=type_._meta.description,
+            description=graphene_type._meta.description,
             types=types,
-            resolve_type=_resolve_type,
+            resolve_type=resolve_type,
         )
 
     def get_name(self, name):
@@ -331,42 +300,69 @@ class GrapheneGraphQLSchema(GraphQLSchema):
             return to_camel_case(name)
         return name
 
-    def construct_fields_for_type(self, map_, type_, is_input_type=False):
+    def create_fields_for_type(self, graphene_type, is_input_type=False):
+        create_graphql_type = self.add_type
+
         fields = {}
-        for name, field in type_._meta.fields.items():
+        for name, field in graphene_type._meta.fields.items():
             if isinstance(field, Dynamic):
                 field = get_field_as(field.get_type(self), _as=Field)
                 if not field:
                     continue
-            map_ = self.type_map_reducer(map_, field.type)
+            field_type = create_graphql_type(field.type)
-            field_type = self.get_field_type(map_, field.type)
             if is_input_type:
                 _field = GraphQLInputField(
                     field_type,
                     default_value=field.default_value,
                     out_name=name,
                     description=field.description,
+                    deprecation_reason=field.deprecation_reason,
                 )
             else:
                 args = {}
                 for arg_name, arg in field.args.items():
-                    map_ = self.type_map_reducer(map_, arg.type)
+                    arg_type = create_graphql_type(arg.type)
-                    arg_type = self.get_field_type(map_, arg.type)
                     processed_arg_name = arg.name or self.get_name(arg_name)
                     args[processed_arg_name] = GraphQLArgument(
                         arg_type,
                         out_name=arg_name,
                         description=arg.description,
-                        default_value=Undefined
+                        default_value=arg.default_value,
-                        if isinstance(arg.type, NonNull)
+                        deprecation_reason=arg.deprecation_reason,
-                        else arg.default_value,
                     )
+                subscribe = field.wrap_subscribe(
+                    self.get_function_for_type(
+                        graphene_type, f"subscribe_{name}", name, field.default_value
+                    )
+                )
+
+                # If we are in a subscription, we use (by default) an
+                # identity-based resolver for the root, rather than the
+                # default resolver for objects/dicts.
+                if subscribe:
+                    field_default_resolver = identity_resolve
+                elif issubclass(graphene_type, ObjectType):
+                    default_resolver = (
+                        graphene_type._meta.default_resolver or get_default_resolver()
+                    )
+                    field_default_resolver = partial(
+                        default_resolver, name, field.default_value
+                    )
+                else:
+                    field_default_resolver = None
+
+                resolve = field.wrap_resolve(
+                    self.get_function_for_type(
+                        graphene_type, f"resolve_{name}", name, field.default_value
+                    )
+                    or field_default_resolver
+                )
+
                 _field = GraphQLField(
                     field_type,
                     args=args,
-                    resolve=field.get_resolver(
+                    resolve=resolve,
-                        self.get_resolver_for_type(type_, name, field.default_value)
+                    subscribe=subscribe,
-                    ),
                     deprecation_reason=field.deprecation_reason,
                     description=field.description,
                 )
@@ -374,18 +370,19 @@ class GrapheneGraphQLSchema(GraphQLSchema):
             fields[field_name] = _field
         return fields
 
-    def get_resolver_for_type(self, type_, name, default_value):
+    def get_function_for_type(self, graphene_type, func_name, name, default_value):
-        if not issubclass(type_, ObjectType):
+        """Gets a resolve or subscribe function for a given ObjectType"""
+        if not issubclass(graphene_type, ObjectType):
             return
-        resolver = getattr(type_, "resolve_{}".format(name), None)
+        resolver = getattr(graphene_type, func_name, None)
         if not resolver:
             # If we don't find the resolver in the ObjectType class, then try to
             # find it in each of the interfaces
             interface_resolver = None
-            for interface in type_._meta.interfaces:
+            for interface in graphene_type._meta.interfaces:
                 if name not in interface._meta.fields:
                     continue
-                interface_resolver = getattr(interface, "resolve_{}".format(name), None)
+                interface_resolver = getattr(interface, func_name, None)
                 if interface_resolver:
                     break
             resolver = interface_resolver
@@ -394,36 +391,33 @@ class GrapheneGraphQLSchema(GraphQLSchema):
         if resolver:
             return get_unbound_function(resolver)
 
-        default_resolver = type_._meta.default_resolver or get_default_resolver()
+    def resolve_type(self, resolve_type_func, type_name, root, info, _type):
-        return partial(default_resolver, name, default_value)
+        type_ = resolve_type_func(root, info)
 
-    def get_field_type(self, map_, type_):
+        if inspect.isclass(type_) and issubclass(type_, ObjectType):
-        if isinstance(type_, List):
+            return type_._meta.name
-            return GraphQLList(self.get_field_type(map_, type_.of_type))
+
-        if isinstance(type_, NonNull):
+        return_type = self[type_name]
-            return GraphQLNonNull(self.get_field_type(map_, type_.of_type))
+        return default_type_resolver(root, info, return_type)
-        return map_.get(type_._meta.name)
 
 
 class Schema:
     """Schema Definition.
-
     A Graphene Schema can execute operations (query, mutation, subscription) against the defined
     types. For advanced purposes, the schema can be used to lookup type definitions and answer
     questions about the types through introspection.
-
     Args:
-        query (ObjectType): Root query *ObjectType*. Describes entry point for fields to *read*
+        query (Type[ObjectType]): Root query *ObjectType*. Describes entry point for fields to *read*
             data in your Schema.
-        mutation (ObjectType, optional): Root mutation *ObjectType*. Describes entry point for
+        mutation (Optional[Type[ObjectType]]): Root mutation *ObjectType*. Describes entry point for
             fields to *create, update or delete* data in your API.
-        subscription (ObjectType, optional): Root subscription *ObjectType*. Describes entry point
+        subscription (Optional[Type[ObjectType]]): Root subscription *ObjectType*. Describes entry point
             for fields to receive continuous updates.
+        types (Optional[List[Type[ObjectType]]]): List of any types to include in schema that
+            may not be introspected through root types.
         directives (List[GraphQLDirective], optional): List of custom directives to include in the
             GraphQL schema. Defaults to only include directives defined by GraphQL spec (@include
             and @skip) [GraphQLIncludeDirective, GraphQLSkipDirective].
-        types (List[GraphQLType], optional): List of any types to include in schema that
-            may not be introspected through root types.
         auto_camelcase (bool): Fieldnames will be transformed in Schema's TypeMap from snake_case
             to camelCase (preferred by GraphQL standard). Default True.
     """
@@ -440,13 +434,15 @@ class Schema:
         self.query = query
         self.mutation = mutation
         self.subscription = subscription
-        self.graphql_schema = GrapheneGraphQLSchema(
+        type_map = TypeMap(
-            query,
+            query, mutation, subscription, types, auto_camelcase=auto_camelcase
-            mutation,
+        )
-            subscription,
+        self.graphql_schema = GraphQLSchema(
-            types,
+            type_map.query,
+            type_map.mutation,
+            type_map.subscription,
+            type_map.types,
             directives,
-            auto_camelcase=auto_camelcase,
         )
 
     def __str__(self):
@@ -456,12 +452,11 @@ class Schema:
         """
         This function let the developer select a type in a given schema
         by accessing its attrs.
-
         Example: using schema.Query for accessing the "Query" type in the Schema
         """
         _type = self.graphql_schema.get_type(type_name)
         if _type is None:
-            raise AttributeError('Type "{}" not found in the Schema'.format(type_name))
+            raise AttributeError(f'Type "{type_name}" not found in the Schema')
         if isinstance(_type, GrapheneGraphQLType):
             return _type.graphene_type
         return _type
@@ -471,11 +466,9 @@ class Schema:
 
     def execute(self, *args, **kwargs):
         """Execute a GraphQL query on the schema.
-
         Use the `graphql_sync` function from `graphql-core` to provide the result
         for a query string. Most of the time this method will be called by one of the Graphene
         :ref:`Integrations` via a web request.
-
         Args:
             request_string (str or Document): GraphQL request (query, mutation or subscription)
                 as string or parsed AST form from `graphql-core`.
@@ -490,7 +483,8 @@ class Schema:
                 request_string, an operation name must be provided for the result to be provided.
             middleware (List[SupportsGraphQLMiddleware]): Supply request level middleware as
                 defined in `graphql-core`.
-
+            execution_context_class (ExecutionContext, optional): The execution context class
+                to use when resolving queries and mutations.
         Returns:
             :obj:`ExecutionResult` containing any data and errors for the operation.
         """
@@ -499,12 +493,28 @@ class Schema:
 
     async def execute_async(self, *args, **kwargs):
         """Execute a GraphQL query on the schema asynchronously.
-
         Same as `execute`, but uses `graphql` instead of `graphql_sync`.
         """
         kwargs = normalize_execute_kwargs(kwargs)
         return await graphql(self.graphql_schema, *args, **kwargs)
 
+    async def subscribe(self, query, *args, **kwargs):
+        """Execute a GraphQL subscription on the schema asynchronously."""
+        # Do parsing
+        try:
+            document = parse(query)
+        except GraphQLError as error:
+            return ExecutionResult(data=None, errors=[error])
+
+        # Do validation
+        validation_errors = validate(self.graphql_schema, document)
+        if validation_errors:
+            return ExecutionResult(data=None, errors=validation_errors)
+
+        # Execute the query
+        kwargs = normalize_execute_kwargs(kwargs)
+        return await subscribe(self.graphql_schema, document, *args, **kwargs)
+
     def introspect(self):
         introspection = self.execute(introspection_query)
         if introspection.errors: