def __init__(self,
schema=None,
introspection=None,
type_def=None,
transport=None,
fetch_schema_from_transport=False,
retries=0,
custom_types={}):
"""custom_types should be of type Dict[str, Any]
where str is the name of the custom scalar type, and
Any is a class which has a `parse_value()` function"""
assert not (
type_def and introspection
), 'Cant provide introspection type definition at the same time'
if transport and fetch_schema_from_transport:
assert not schema, 'Cant fetch the schema from transport if is already provided'
introspection = transport.execute(parse(introspection_query)).data
if introspection:
assert not schema, 'Cant provide introspection and schema at the same time'
schema = build_client_schema(introspection)
elif type_def:
assert not schema, 'Cant provide Type definition and schema at the same time'
type_def_ast = parse(type_def)
schema = build_ast_schema(type_def_ast)
elif schema and not transport:
transport = LocalSchemaTransport(schema)
self.schema = schema
self.introspection = introspection
self.transport = transport
self.retries = retries
self.type_adapter = TypeAdapter(schema,
custom_types) if custom_types else None
def __init__(
self,
schema: Optional[Union[str, GraphQLSchema]] = None,
introspection=None,
type_def: Optional[str] = None,
transport: Optional[Union[Transport, AsyncTransport]] = None,
fetch_schema_from_transport: bool = False,
execute_timeout: Optional[int] = 10,
):
assert not (
type_def and introspection
), "Cannot provide introspection and type definition at the same time."
if type_def:
assert (
not schema
), "Cannot provide type definition and schema at the same time."
warnings.warn(
"type_def is deprecated; use schema instead",
category=DeprecationWarning,
)
schema = type_def
if introspection:
assert (
not schema
), "Cannot provide introspection and schema at the same time."
schema = build_client_schema(introspection)
if isinstance(schema, str):
type_def_ast = parse(schema)
schema = build_ast_schema(type_def_ast)
if transport and fetch_schema_from_transport:
assert (
not schema
), "Cannot fetch the schema from transport if is already provided."
if schema and not transport:
transport = LocalSchemaTransport(schema)
# GraphQL schema
self.schema: Optional[GraphQLSchema] = schema
# Answer of the introspection query
self.introspection = introspection
# GraphQL transport chosen
self.transport: Optional[Union[Transport, AsyncTransport]] = transport
# Flag to indicate that we need to fetch the schema from the transport
# On async transports, we fetch the schema before executing the first query
self.fetch_schema_from_transport: bool = fetch_schema_from_transport
# Enforced timeout of the execute function
self.execute_timeout = execute_timeout
if isinstance(transport, Transport) and fetch_schema_from_transport:
with self as session:
session.fetch_schema()
def __init__(
self,
schema=None,
introspection=None,
type_def=None,
transport=None,
fetch_schema_from_transport=False,
retries=0,
):
assert not (
type_def and introspection
), "Cant provide introspection type definition at the same time"
if transport and fetch_schema_from_transport:
assert (
not schema
), "Cant fetch the schema from transport if is already provided"
introspection = transport.execute(parse(introspection_query)).data
if introspection:
assert not schema, "Cant provide introspection and schema at the same time"
schema = build_client_schema(introspection)
elif type_def:
assert (
not schema
), "Cant provide Type definition and schema at the same time"
type_def_ast = parse(type_def)
schema = build_ast_schema(type_def_ast)
elif schema and not transport:
transport = LocalSchemaTransport(schema)
self.schema = schema
self.introspection = introspection
self.transport = transport
self.retries = retries
def test_build_schema_from_introspection(
benchmark,
big_schema_introspection_result # noqa: F811
):
schema: GraphQLSchema = benchmark(lambda: build_client_schema(
big_schema_introspection_result["data"], assume_valid=True))
assert schema.query_type is not None
def make_remote_executable_schema(url: str) -> graphql.GraphQLSchema:
"""
Creates an executable GraphQL schema from a remote endpoint.
"""
client = GraphQLClient(url=url)
introspection_result = client.execute(graphql.get_introspection_query())
schema = graphql.build_client_schema(introspection_result.data)
def root_resolver(obj, info, **inputs):
query = graphql.print_ast(info.operation)
# TODO: add graphql context
delegated_result = client.execute(query=query,
variables=info.variable_values)
return delegated_result.data[info.field_name]
# apply root resolver to any field on query or mutation roots
resolvers = {
schema.query_type.name:
{q: root_resolver
for q in schema.query_type.fields},
schema.mutation_type.name:
{q: root_resolver
for q in schema.mutation_type.fields},
}
ariadne.resolvers.add_resolve_functions_to_schema(schema, resolvers)
return schema
def __init__(
self,
schema: Optional[GraphQLSchema] = None,
introspection: Optional[Dict[str, Any]] = None,
type_def: Optional[str] = None,
transport: Optional[Transport] = None,
fetch_schema_from_transport: bool = False,
retries: int = 0,
) -> None:
assert not (
type_def and introspection
), "Cant provide introspection type definition at the same time"
if transport and fetch_schema_from_transport:
assert (
not schema
), "Cant fetch the schema from transport if is already provided"
introspection = transport.execute(
parse(get_introspection_query(descriptions=True))).data
if introspection:
assert not schema, "Cant provide introspection and schema at the same time"
schema = build_client_schema(introspection)
elif type_def:
assert (
not schema
), "Cant provide Type definition and schema at the same time"
type_def_ast = parse(type_def)
schema = build_ast_schema(type_def_ast)
elif schema and not transport:
transport = LocalSchemaTransport(schema)
self.schema = schema
self.introspection = introspection
self.transport = cast(Transport, transport)
self.retries = retries
def get_case_strategy(
self,
endpoint: Endpoint,
hooks: Optional[HookDispatcher] = None,
feedback: Optional[Feedback] = None) -> SearchStrategy:
constructor = partial(GraphQLCase, endpoint=endpoint)
schema = graphql.build_client_schema(self.raw_schema)
return st.builds(constructor, body=gql_st.query(schema))
async def introspection(self):
status, result = await self.execute(get_introspection_query())
if status != 200:
raise ValueError(
f"Error in schema introspection. {status} - {result}")
schema = build_client_schema(result.data)
self.dsl = DSLSchema(schema, camelcase=self.camelcase)
return schema
async def fetch_schema(self) -> None:
"""Fetch the GraphQL schema explicitely using introspection.
Don't use this function and instead set the fetch_schema_from_transport
attribute to True"""
execution_result = await self.transport.execute(
parse(get_introspection_query()))
self.client.introspection = execution_result.data
self.client.schema = build_client_schema(self.client.introspection)
def get_case_strategy(
self,
operation: APIOperation,
hooks: Optional[HookDispatcher] = None,
data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
) -> SearchStrategy:
constructor = partial(GraphQLCase, operation=operation)
schema = graphql.build_client_schema(self.raw_schema)
return st.builds(constructor, body=gql_st.query(schema))
def _cache_v4_schema():
global _V4_SCHEMA
if _V4_SCHEMA:
return
with open('github_v4_schema.graphql') as source:
introspection = json.loads(source.read())
_V4_SCHEMA = build_client_schema(introspection)
def main():
pp = PrettyPrinter(indent=4)
client = GraphQLClient('http://swapi.graph.cool/')
query_intros = get_introspection_query(descriptions=True)
intros_result = client.execute(query_intros,
variables=None,
operationName=None)
client_schema = build_client_schema(intros_result.get('data', None))
sdl = print_schema(client_schema)
print(sdl)
pp.pprint(sdl)
def load_schema(schema_path):
"""Load the Intuit Schema. Apparently it differs a bit from what
Graphene wants, specifically Graphene doesn't recognize the
top-level "errors" and "data" fields
"""
with open(os.path.abspath(schema_path)) as ifile:
ischema = json.load(ifile)
if "data" in ischema:
ischema = ischema["data"]
return graphql.build_client_schema(ischema)
def get_schema(self):
gql_introspection_schema = self.options.get('gql_introspection_schema')
if gql_introspection_schema:
try:
with open(gql_introspection_schema) as data_file:
introspection_schema = json.load(data_file)
return build_client_schema(introspection_schema)
except IOError as e:
raise Exception("Cannot find the provided introspection schema. {}".format(str(e)))
schema = self.options.get('schema')
assert schema, 'Need to provide schema'
def get_schema(self):
pygql_introspection_schema = self.options.get('pygql_introspection_schema')
if gql_introspection_schema:
try:
with open(pygql_introspection_schema) as data_file:
introspection_schema = json.load(data_file)
return build_client_schema(introspection_schema)
except IOError as e:
raise Exception("Cannot find the provided introspection schema. {}".format(str(e)))
schema = self.options.get('schema')
assert schema, 'Need to provide schema'
def convert_from_file(self, value, param, ctx):
f = click.File('r').convert(value, param, ctx)
try:
introspection = json.load(f)['data']
schema = graphql.build_client_schema(introspection)
except (ValueError, KeyError) as e:
self.fail('File content is not valid a graphql schema %s.' % e,
param=param,
ctx=ctx)
return schema
def main():
pp = PrettyPrinter(indent=4)
# query over the network
query_intros = get_introspection_query(descriptions=True)
#introspection_query_result = graphql_sync(schema, query)
intros_result = client.execute(query_intros,
variables=None,
operationName=None)
client_schema = build_client_schema(intros_result.get('data', None))
sdl = print_schema(client_schema)
print(sdl)
pp.pprint(sdl)
print("\n")
# query again using the graphql_sync()
from graphql import graphql_sync
introspection_query_result = graphql_sync(client_schema, query_intros)
client_schema = build_client_schema(introspection_query_result.data)
sdl = print_schema(client_schema)
print(sdl)
pp.pprint(sdl)
print("\n")
def query_for_schema(provider):
"""
Asks the given provider for its schema
"""
prov = get_provider(provider)
if hasattr(prov, 'get_schema_str'):
data = prov.get_schema_str()
schema = graphql.build_schema(data)
else:
query = graphql.get_introspection_query(descriptions=True)
data = exec_query_sync(provider, query)
schema = graphql.build_client_schema(data)
schema = insert_builtins(schema)
return schema
def IntrospectionQuery(endpoint, filename):
url = endpoint
# for headers request
headers = {
"User-Agent":
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:67.0) Gecko/20100101 Firefox/67.0",
"Accept": "*/*",
"Accept-Language": "id,en-US;q=0.7,en;q=0.3",
"Accept-Encoding": "gzip, deflate",
"content-type": "application/json"
}
# Post Request Query for grab schema IntrospectionQuery
body = {
"query":
"query IntrospectionQuery {__schema {queryType { name },mutationType { name },subscriptionType { name },types {...FullType},directives {name,description,args {...InputValue},onOperation,onFragment,onField,locations}}}\nfragment FullType on __Type {kind,name,description,fields(includeDeprecated: true) {name,description,args {...InputValue},type {...TypeRef},isDeprecated,deprecationReason},inputFields {...InputValue},interfaces {...TypeRef},enumValues(includeDeprecated: true) {name,description,isDeprecated,deprecationReason},possibleTypes {...TypeRef}}\nfragment InputValue on __InputValue {name,description,type { ...TypeRef },defaultValue}\nfragment TypeRef on __Type {kind,name,ofType {kind,name,ofType {kind,name,ofType {kind,name}}}}"
}
data = requests.post(url, headers=headers, json=body)
status = data.status_code
print("\n[+] Checking endpoint ", endpoint, " .. ")
if (status == 400):
print("[+] IntrospectionQuery Now Allowed")
if (status == 200):
print("[+] IntrospectionQuery Allowed ")
print("[+] Saving IntrospectionQuery to folder output .. ")
save = (json.loads(data.text))
filename_saved = 'output/' + filename + ".json"
with open(filename_saved, 'w') as outfile:
json.dump(save, outfile)
print("[+] __schema saved in ", filename_saved)
# Convert to client schema
instropection = json.loads(data.text)
client_schema = build_client_schema(instropection['data'])
_schema = print_schema(client_schema)
print(_schema)
print("[+] Saving client_schema to folder output ..")
client_schema_saved = 'output/' + filename + ".schema"
with open(client_schema_saved, 'w') as file:
file.write(_schema)
print("[+] client_schema saved in ", client_schema_saved)
def __init__(self, schema=None, introspection=None, type_def=None, transport=None,
fetch_schema_from_transport=False, retries=0):
assert not(type_def and introspection), 'Cant provide introspection type definition at the same time'
if transport and fetch_schema_from_transport:
assert not schema, 'Cant fetch the schema from transport if is already provided'
introspection = transport.execute(parse(introspection_query)).data
if introspection:
assert not schema, 'Cant provide introspection and schema at the same time'
schema = build_client_schema(introspection)
elif type_def:
assert not schema, 'Cant provide Type definition and schema at the same time'
type_def_ast = parse(type_def)
schema = build_ast_schema(type_def_ast)
elif schema and not transport:
transport = LocalSchemaTransport(schema)
self.schema = schema
self.introspection = introspection
self.transport = transport
self.retries = retries
def _resolve_url(ctx, url: str) -> Optional[GraphQLSchema]:
query = get_introspection_query(descriptions=True)
try:
response = requests.post(url,
data={"query": query},
headers={"Accept": "application/json"})
response.raise_for_status()
except requests.RequestException:
raise ValueError("Could not download schema")
try:
data = response.json()
except json.decoder.JSONDecodeError:
raise ValueError("Received invalid JSON from GraphQL endpoint")
try:
return build_client_schema(data["data"])
except Exception:
raise ValueError("Could not decode schema")
def initialize(self):
loop = tornado.ioloop.IOLoop.current()
generate_schema()
api_schema = get_api_schema()
module_schema = get_module_schema()
if options.generate_schema_and_exit:
query = get_introspection_query(descriptions=False)
introspection_query_result = graphql_sync(api_schema, query)
client_schema = build_client_schema(introspection_query_result.data)
sdl = print_schema(client_schema)
with open(
Path(options.basedir).joinpath("..", "schema.graphql").resolve(), "w+"
) as fid:
fid.write(sdl)
sys.exit(0)
start_all_modules()
self.database = None # MavDatabase()
application = TornadoQL()
# Start Non-SSL server
server = tornado.httpserver.HTTPServer(application)
server.listen(port=options.server_port_nonssl, address=options.server_interface)
application_log.info(
f"Starting Maverick API server: {options.server_interface}:{options.server_port_nonssl}/{options.app_prefix}"
)
# Start SSL server, unless disabled
if not options.disable_ssl:
ssl_options = self.get_ssl_options()
server = tornado.httpserver.HTTPServer(application, ssl_options=ssl_options)
server.listen(
port=options.server_port_ssl, address=options.server_interface
)
application_log.info(
f"Starting Maverick API server - SSL: {options.server_interface}:{options.server_port_ssl}/{options.app_prefix}"
)
async def introspect(
self, headers: Optional[Dict[str, str]] = None
) -> graphql.GraphQLSchema:
"""
Introspect the GraphQL endpoint specified for this client and return a `graphql.GraphQLSchema` object
specifying the schema associated with this endpoint.
:return: GraphQL schema for the configured endpoint
"""
request = GraphQLRequest(
query=graphql.get_introspection_query(descriptions=False),
validate=False,
headers=headers,
)
introspection = await self.query(request)
try:
return graphql.build_client_schema(introspection=introspection.data)
except TypeError:
raise GraphQLIntrospectionException(
f"Failed to build schema from introspection data: {introspection.errors}"
)
def __init__(
self,
schema=None,
introspection=None,
type_def=None,
transport=None,
fetch_schema_from_transport=False,
retries=0, # We should remove this parameter and let the transport level handle it
):
assert not (
type_def and introspection
), "Cannot provide introspection type definition at the same time."
if transport and fetch_schema_from_transport:
assert (
not schema
), "Cannot fetch the schema from transport if is already provided"
introspection = transport.execute(parse(introspection_query)).data
if introspection:
assert (
not schema
), "Cannot provide introspection and schema at the same time."
schema = build_client_schema(introspection)
elif type_def:
assert (
not schema
), "Cannot provide type definition and schema at the same time."
type_def_ast = parse(type_def)
schema = build_ast_schema(type_def_ast)
elif schema and not transport:
transport = LocalSchemaTransport(schema)
self.schema = schema
self.introspection = introspection
self.transport = transport
self.retries = retries
if self.retries:
log.warning(
"The retries parameter on the Client class is deprecated."
"You can pass it to the RequestsHTTPTransport.")
async def fetch_schema(self) -> None:
execution_result = await self.transport.execute(
parse(get_introspection_query())
)
self.client.introspection = execution_result.data
self.client.schema = build_client_schema(self.client.introspection)
def __init__(
self,
schema: Optional[Union[str, GraphQLSchema]] = None,
introspection=None,
type_def: Optional[str] = None,
transport: Optional[Union[Transport, AsyncTransport]] = None,
fetch_schema_from_transport: bool = False,
execute_timeout: Optional[int] = 10,
):
"""Initialize the client with the given parameters.
:param schema: an optional GraphQL Schema for local validation
See :ref:`schema_validation`
:param transport: The provided :ref:`transport <Transports>`.
:param fetch_schema_from_transport: Boolean to indicate that if we want to fetch
the schema from the transport using an introspection query
:param execute_timeout: The maximum time in seconds for the execution of a
request before a TimeoutError is raised. Only used for async transports.
"""
assert not (
type_def and introspection
), "Cannot provide introspection and type definition at the same time."
if type_def:
assert (
not schema
), "Cannot provide type definition and schema at the same time."
warnings.warn(
"type_def is deprecated; use schema instead",
category=DeprecationWarning,
)
schema = type_def
if introspection:
assert (
not schema
), "Cannot provide introspection and schema at the same time."
schema = build_client_schema(introspection)
if isinstance(schema, str):
type_def_ast = parse(schema)
schema = build_ast_schema(type_def_ast)
if transport and fetch_schema_from_transport:
assert (
not schema
), "Cannot fetch the schema from transport if is already provided."
if schema and not transport:
transport = LocalSchemaTransport(schema)
# GraphQL schema
self.schema: Optional[GraphQLSchema] = schema
# Answer of the introspection query
self.introspection = introspection
# GraphQL transport chosen
self.transport: Optional[Union[Transport, AsyncTransport]] = transport
# Flag to indicate that we need to fetch the schema from the transport
# On async transports, we fetch the schema before executing the first query
self.fetch_schema_from_transport: bool = fetch_schema_from_transport
# Enforced timeout of the execute function (only for async transports)
self.execute_timeout = execute_timeout
def __attrs_post_init__(self) -> None:
self.schema = graphql.build_client_schema(self.raw_schema)
def load_schema(uri):
introspection = load_introspection_from_file(uri) if os.path.isfile(uri) else load_introspection_from_server(uri)
return build_client_schema(introspection)
def gql_schema(anon_user_gql_client):
introspection = anon_user_gql_client.execute(introspection_query)
return build_client_schema(introspection["data"])
def client_schema(self) -> graphql.GraphQLSchema:
return graphql.build_client_schema(self.raw_schema)
def load_schema(uri):
introspection = load_introspection_from_file(uri) if os.path.isfile(
uri) else load_introspection_from_server(uri)
return build_client_schema(introspection)
