async def cook( self, sdl: Union[str, List[str]], error_coercer: Callable[[Exception], dict] = None, custom_default_resolver: Optional[Callable] = None, modules: Optional[Union[str, List[str]]] = None, schema_name: str = "default", ): """ Cook the tartiflette, basicly prepare the engine by binding it to given modules using the schema_name as a key. You wont be able to execute a request if the engine wasn't cooked. Arguments: sdl {Union[str, List[str]]} -- The SDL to work with. Keyword Arguments: schema_name {str} -- The name of the SDL (default: {"default"}) error_coercer {Callable[[Exception, dict], dict]} -- An optional callable in charge of transforming a couple Exception/error into an error dict (default: {default_error_coercer}) custom_default_resolver {Optional[Callable]} -- An optional callable that will replace the tartiflette default_resolver (Will be called like a resolver for each UNDECORATED field) (default: {None}) modules {Optional[Union[str, List[str]]]} -- An optional list of string containing the name of the modules you want the engine to import, usually this modules contains your Resolvers, Directives, Scalar or Subscription code (default: {None}) """ if not modules: modules = [] if isinstance(modules, str): modules = [modules] self._error_coercer = error_coercer_factory(error_coercer or default_error_coercer) self._modules, modules_sdl = await _import_modules( modules, schema_name) SchemaRegistry.register_sdl(schema_name, sdl, modules_sdl) self._schema = SchemaBakery.bake(schema_name, custom_default_resolver)
async def cook( self, sdl: Union[str, List[str]] = None, error_coercer: Callable[[Exception], dict] = None, custom_default_resolver: Optional[Callable] = None, modules: Optional[Union[str, List[str]]] = None, schema_name: str = None, ): """ Cook the tartiflette, i.e. prepare the engine by binding it to given modules using the schema_name as a key. You won't be able to execute a request if the engine hasn't been cooked. Has no effect if the engine has already been cooked. Keyword Arguments: sdl {Union[str, List[str]]} -- The SDL to work with. schema_name {str} -- The name of the SDL (default: {"default"}) error_coercer {Callable[[Exception, dict], dict]} -- An optional callable in charge of transforming a couple Exception/error into an error dict (default: {default_error_coercer}) custom_default_resolver {Optional[Callable]} -- An optional callable that will replace the tartiflette default_resolver (Will be called like a resolver for each UNDECORATED field) (default: {None}) modules {Optional[Union[str, List[str]]]} -- An optional list of string containing the name of the modules you want the engine to import, usually this modules contains your Resolvers, Directives, Scalar or Subscription code (default: {None}) """ if self._cooked: return if modules is None: modules = self._modules or [] if isinstance(modules, str): modules = [modules] sdl = sdl or self._sdl if not sdl: raise Exception("Please provide a SDL") schema_name = schema_name or self._schema_name or "default" custom_default_resolver = (custom_default_resolver or self._custom_default_resolver) if custom_default_resolver and not iscoroutinefunction( custom_default_resolver): raise Exception(f"Given custom_default_resolver " f"{custom_default_resolver} " f"is not a coroutine function") self._error_coercer = error_coercer_factory(error_coercer or self._error_coercer or default_error_coercer) self._modules, modules_sdl = await _import_modules( modules, schema_name) SchemaRegistry.register_sdl(schema_name, sdl, modules_sdl) self._schema = SchemaBakery.bake(schema_name, custom_default_resolver) self._cooked = True
def __init__( self, sdl: Union[str, List[str]], schema_name: str = "default", error_coercer: Callable[[Exception], dict] = default_error_coercer, custom_default_resolver: Optional[Callable] = None, exclude_builtins_scalars: Optional[List[str]] = None, modules: Optional[Union[str, List[str]]] = None, ) -> None: """Create an engine by analyzing the SDL and connecting it with the imported Resolver, Mutation, Subscription, Directive and Scalar linking them through the schema_name. Then using `await an_engine.execute(query)` will resolve your GQL requests. Arguments: sdl {Union[str, List[str]]} -- The SDL to work with. Keyword Arguments: schema_name {str} -- The name of the SDL (default: {"default"}) error_coercer {Callable[[Exception], dict]} -- An optional callable in charge of transforming an Exception into an error dict (default: {default_error_coercer}) custom_default_resolver {Optional[Callable]} -- An optional callable that will replace the tartiflette default_resolver (Will be called like a resolver for each UNDECORATED field) (default: {None}) exclude_builtins_scalars {Optional[List[str]]} -- An optional list of string containing the names of the builtin scalar you don't want to be automatically included, usually it's Date, DateTime or Time scalars (default: {None}) modules {Optional[Union[str, List[str]]]} -- An optional list of string containing the name of the modules you want the engine to import, usually this modules contains your Resolvers, Directives, Scalar or Subscription code (default: {None}) """ if isinstance(modules, str): modules = [modules] self._modules = _import_modules(modules) self._error_coercer = error_coercer self._parser = TartifletteRequestParser() SchemaRegistry.register_sdl(schema_name, sdl, exclude_builtins_scalars) self._schema = SchemaBakery.bake( schema_name, custom_default_resolver, exclude_builtins_scalars )
async def cook( self, sdl: Union[str, List[str]] = None, error_coercer: Callable[[Exception, Dict[str, Any]], Dict[str, Any]] = None, custom_default_resolver: Optional[Callable] = None, custom_default_type_resolver: Optional[Callable] = None, modules: Optional[Union[str, List[str], List[Dict[str, Any]]]] = None, schema_name: str = None, ) -> None: """ Cook the tartiflette, basically prepare the engine by binding it to given modules using the schema_name as a key. You wont be able to execute a request if the engine wasn't cooked. :param sdl: path or list of path to the files / directories containing the SDL :param error_coercer: callable in charge of transforming a couple Exception/error into an error dictionary :param custom_default_resolver: callable that will replace the builtin default_resolver (called as resolver for each UNDECORATED field) :param custom_default_type_resolver: callable that will replace the tartiflette `default_type_resolver` (will be called on abstract types to deduct the type of a result) :param modules: list of string containing the name of the modules you want the engine to import, usually this modules contains your Resolvers, Directives, Scalar or Subscription code :param schema_name: name of the SDL :type sdl: Union[str, List[str]] :type error_coercer: Callable[[Exception, Dict[str, Any]], Dict[str, Any]] :type custom_default_resolver: Optional[Callable] :type custom_default_type_resolver: Optional[Callable] :type modules: Optional[Union[str, List[str], List[Dict[str, Any]]]] :type schema_name: str """ if self._cooked: return if modules is None: modules = self._modules or [] if isinstance(modules, str): modules = [modules] sdl = sdl or self._sdl if not sdl: raise Exception("Please provide a SDL") schema_name = schema_name or self._schema_name or "default" custom_error_coercer = error_coercer or self._error_coercer if custom_error_coercer and not is_valid_coroutine( custom_error_coercer): raise NonCoroutine( "Given < error_coercer > is not a coroutine callable.") custom_default_resolver = (custom_default_resolver or self._custom_default_resolver) if custom_default_resolver and not is_valid_coroutine( custom_default_resolver): raise NonCoroutine( "Given < custom_default_resolver > is not a coroutine callable." ) custom_default_type_resolver = (custom_default_type_resolver or self._custom_default_type_resolver) if custom_default_type_resolver and not callable( custom_default_type_resolver): raise NonCallable( "Given < custom_default_type_resolver > is not a coroutine callable." ) self._error_coercer = error_coercer_factory(custom_error_coercer or default_error_coercer) self._modules, modules_sdl = await _import_modules( modules, schema_name) SchemaRegistry.register_sdl(schema_name, sdl, modules_sdl) self._schema = await SchemaBakery.bake(schema_name, custom_default_resolver, custom_default_type_resolver) self._build_response = partial(build_response, error_coercer=self._error_coercer) self._cooked = True
async def cook( self, sdl: Union[str, List[str]] = None, error_coercer: Callable[[Exception, Dict[str, Any]], Dict[str, Any]] = None, custom_default_resolver: Optional[Callable] = None, custom_default_type_resolver: Optional[Callable] = None, modules: Optional[Union[str, List[str], List[Dict[str, Any]]]] = None, query_cache_decorator: Optional[Callable] = UNDEFINED_VALUE, json_loader: Optional[Callable[[str], Dict[str, Any]]] = None, custom_default_arguments_coercer: Optional[Callable] = None, coerce_list_concurrently: Optional[bool] = None, schema_name: Optional[str] = None, ) -> None: """ Cook the tartiflette, basically prepare the engine by binding it to given modules using the schema_name as a key. You wont be able to execute a request if the engine wasn't cooked. :param sdl: path or list of path to the files / directories containing the SDL :param error_coercer: callable in charge of transforming a couple Exception/error into an error dictionary :param custom_default_resolver: callable that will replace the builtin default_resolver (called as resolver for each UNDECORATED field) :param custom_default_type_resolver: callable that will replace the tartiflette `default_type_resolver` (will be called on abstract types to deduct the type of a result) :param modules: list of string containing the name of the modules you want the engine to import, usually this modules contains your Resolvers, Directives, Scalar or Subscription code :param query_cache_decorator: callable that will replace the tartiflette default lru_cache decorator to cache query parsing :param json_loader: A callable that will replace default python json module.loads for ast_json loading :param custom_default_arguments_coercer: callable that will replace the tartiflette `default_arguments_coercer` :param coerce_list_concurrently: whether or not list will be coerced concurrently :param schema_name: name of the SDL :type sdl: Union[str, List[str]] :type error_coercer: Callable[[Exception, Dict[str, Any]], Dict[str, Any]] :type custom_default_resolver: Optional[Callable] :type custom_default_type_resolver: Optional[Callable] :type modules: Optional[Union[str, List[str], List[Dict[str, Any]]]] :type query_cache_decorator: Optional[Callable] :type json_loader: Optional[Callable[[str], Dict[str, Any]]] :type custom_default_arguments_coercer: Optional[Callable] :type coerce_list_concurrently: Optional[bool] :type schema_name: Optional[str] """ # pylint: disable=too-many-arguments,too-many-locals if self._cooked: return if modules is None: modules = self._modules or [] if isinstance(modules, str): modules = [modules] sdl = sdl or self._sdl if not sdl: raise Exception("Please provide a SDL") schema_name = schema_name or self._schema_name or "default" custom_error_coercer = error_coercer or self._error_coercer if custom_error_coercer and not is_valid_coroutine( custom_error_coercer): raise NonCoroutine( "Given < error_coercer > is not a coroutine callable.") custom_default_resolver = (custom_default_resolver or self._custom_default_resolver) if custom_default_resolver and not is_valid_coroutine( custom_default_resolver): raise NonCoroutine( "Given < custom_default_resolver > is not a coroutine callable." ) custom_default_type_resolver = (custom_default_type_resolver or self._custom_default_type_resolver) if custom_default_type_resolver and not callable( custom_default_type_resolver): raise NonCallable( "Given < custom_default_type_resolver > is not a coroutine callable." ) custom_default_arguments_coercer = ( custom_default_arguments_coercer or self._custom_default_arguments_coercer) if custom_default_arguments_coercer and not is_valid_coroutine( custom_default_arguments_coercer): raise NonCoroutine( "Given < custom_default_arguments_coercer > is not a " "coroutine callable.") self._error_coercer = error_coercer_factory(custom_error_coercer or default_error_coercer) self._modules, modules_sdl = await _import_modules( modules, schema_name) SchemaRegistry.register_sdl(schema_name, sdl, modules_sdl) self._schema = await SchemaBakery.bake( schema_name, custom_default_resolver, custom_default_type_resolver, custom_default_arguments_coercer, (coerce_list_concurrently if coerce_list_concurrently is not None else self._coerce_list_concurrently), ) self._build_response = partial(build_response, error_coercer=self._error_coercer) ( self._query_executor, self._subscription_executor, ) = self._schema.bake_execute(self._perform_query, self._perform_subscription) if query_cache_decorator is UNDEFINED_VALUE: query_cache_decorator = self._query_cache_decorator self._cached_parse_and_validate_query = ( query_cache_decorator(parse_and_validate_query) if callable(query_cache_decorator) else parse_and_validate_query) self._schema.json_loader = json_loader or self._json_loader self._cooked = True