Circular import solution

Inizia esaminando graphene/types/schema.py nella sezione relativa a construct_fields_for_type e i metodi get_type/import_string di utils, quindi riproduci l’esempio di importazione circolare della discussione collegata. Il lavoro è completato quando si determina se passare lo schema risolve l’esempio senza compromettere la risoluzione dei tipi esistente e si documenta la decisione risultante.

I would like to contribute a solution to the circular import problem. As far as I can see, currently this problem has some workaround through the Dynamic type:
https://github.com/graphql-python/graphene/issues/522#issuecomment-626075061

From my point of view strategy described in this link is pretty much elegant, since it uses type argument from Scheme constructor, which has relevant description:

types (List[GraphQLType], optional): List of any types to include in schema that
            may not be introspected through root types.

But instead of creating new types and making syntax even more complicated and non-readable, I would like to propose a solution with schema pushing down to the import_string method from utils.
Apparently, it was not difficult task:

I made fast and simple changes in interfaces, in order to do this:

Changed type method interface of Field class:

    def type(self, schema):
        return get_type(self._type, schema)

Then reducer invocation here :

    def construct_fields_for_type(self, map, type, is_input_type=False):
        fields = OrderedDict()
        for name, field in type._meta.fields.items():
            if isinstance(field, Dynamic):
                field = get_field_as(field.get_type(self.schema), _as=Field)
                if not field:
                    continue
            map = self.reducer(map, field.type(self.schema))
            field_type = self.get_field_type(map, field.type(self.schema))

Small changes for get_type method:

def get_type(_type, schema=None):
    if isinstance(_type, string_types):
        return import_string(_type, schema=schema)

def import_string(type_name, dotted_attributes=None, schema=None):
    if schema:
        try:
            scheme_type = next(type_ for type_ in schema.types if type_._meta.name == type_name)
            return scheme_type
        except StopIteration:
            pass
   ....

At the end of a day I was able to run code from link without problems.

from graphene import ObjectType, List


class FooBarBaz(ObjectType):
    foo_bars = List('FooBar', required= True)

It is a small fix, I made them with respect to my first impression of graphene structure.

Please, give me feedback, if this solution is okay for you, I will make a pull request.
If not, please, describe why and how can I then avoid circular import