def test_add_graphql_route(): app = Starlette() app.add_route("/", GraphQLApp(schema=schema)) client = TestClient(app) response = client.get("/?query={ hello }") assert response.status_code == 200 assert response.json() == {"data": {"hello": "Hello stranger"}}
def add_graphql(): import vaex.graphql import graphene from starlette.graphql import GraphQLApp dfs = {name: vaex.from_dataset(ds) for name, ds in datasets.items()} Query = vaex.graphql.create_query(dfs) schema = graphene.Schema(query=Query) app.add_route("/graphql", GraphQLApp(schema=schema))
def test_graphql_context(): app = Starlette() app.add_middleware(FakeAuthMiddleware) app.add_route("/", GraphQLApp(schema=schema)) client = TestClient(app) response = client.post("/", json={"query": "{ whoami }"}, headers={"Authorization": "Bearer 123"}) assert response.status_code == 200 assert response.json() == {"data": {"whoami": "Jane"}}
def get_routes(self): routes = [ Route( self._prefix, GraphQLApp(schema=self._schema, executor_class=AsyncioExecutor), methods=["POST"], name="graphql", ), ] return routes
def create_app(): routes = [ Route( '/', GraphQLApp( schema=graphene.Schema(query=Query, mutation=Mutation), executor_class=AsyncioExecutor, graphiql=True, )) ] '''middleware = [Middleware(CORSMiddleware, allow_origins=['*'], allow_headers=['*'], allow_methods=['*'])]''' middleware = [ Middleware(CORSMiddleware, allow_origins=['*'], allow_headers=['*'], allow_methods=['*']), Middleware(HTTPSRedirectMiddleware) ] app = Starlette(routes=routes, middleware=middleware) return app
def setup_routes(app: Starlette) -> None: """Add all of lamia's default routes. TODO: A different setup function should be added to do the same for routes associated with extensions. """ # Static content loading app.mount('/static', StaticFiles(directory='statics'), name='static') # Just a boring test route app.add_route('/', lamia_general.introduction, ['GET']) # Nodeinfo routes app.add_route('/.well-known/nodeinfo', lamia_nodeinfo.nodeinfo_index, ['GET']) app.add_route('/nodeinfo/2.0.json', lamia_nodeinfo.nodeinfo_schema_20, ['GET']) # Graph QL endpoint app.add_route( '/graphql', GraphQLApp(schema=graphene.Schema(query=Queries, mutation=Mutations), executor_class=AsyncioExecutor))
class Circle(graphene.ObjectType): radius = graphene.Float(required=True) class Shape(graphene.Union): class Meta: types = (Square, Rectangle, Circle) class Query(graphene.ObjectType): shape = Shape() def resolve_shape(self, info): choice = randint(1, 3) if choice == 1: return Square(side_len=10.123) if choice == 2: return Rectangle(width=10, height=20) if choice == 3: return Circle(radius=2.56) app = FastAPI() app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"], ) app.add_route("/", GraphQLApp(schema=graphene.Schema(query=Query)))
ensemble = gr.Field(Ensemble, id=gr.ID(required=True)) @staticmethod def resolve_experiments(root: Any, info: ResolveInfo) -> None: return ["default"] @staticmethod def resolve_experiment(root: Any, info: ResolveInfo, id: str) -> None: return "default" @staticmethod def resolve_ensemble(root: Any, info: ResolveInfo, id: str) -> None: return get_name("ensemble", id) class Mutations(gr.ObjectType): create_experiment = CreateExperiment.Field() create_ensemble = gr.Field( CreateEnsemble, active_realizations=gr.List(gr.Int), parameter_names=gr.List(gr.String), size=gr.Int(), experiment_id=gr.ID(required=True), ) schema = gr.Schema(query=Query, mutation=Mutations) graphql_app = GraphQLApp(schema=schema) router = APIRouter(tags=["graphql"]) router.add_route("/gql", graphql_app)
return MappingModel.objects.get(user_id=user_id) def resolve_users_to_genomes(self, info, user_ids): return list(MappingModel.objects(user_id__in=user_ids)) app = FastAPI() @app.on_event("startup") def connect_db_client(): connect("genetrustee") @app.on_event("shutdown") def shutdown_db_client(): disconnect_all origins = ["*"] app.add_middleware( CORSMiddleware, allow_origins=origins, allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) app.add_route( "/", GraphQLApp(schema=graphene.Schema(query=Query, mutation=Mutations)))
class Query(graphene.ObjectType): hello = graphene.String(name=graphene.String(default_value="stranger")) whoami = graphene.String() def resolve_hello(self, info, name): return "Hello " + name def resolve_whoami(self, info): return ("a mystery" if info.context["request"]["user"] is None else info.context["request"]["user"]) schema = graphene.Schema(query=Query) app = GraphQLApp(schema=schema) client = TestClient(app) def test_graphql_get(): response = client.get("/?query={ hello }") assert response.status_code == 200 assert response.json() == { "data": { "hello": "Hello stranger" }, "errors": None } def test_graphql_post():
def make_app(): return GraphQLApp(schema=graphene.Schema(query=Query))
router_custom_app.include_router(router_custom_app_cascade) router_custom_app.include_router(router_custom_app_ws) # graphql class Query(graphene.ObjectType): hello = graphene.String(name=graphene.String(default_value="stranger")) def resolve_hello(self, info, name): return "Hello " + name # graphql - http://127.0.0.1:3000/api/graphql (it did not recognize prefix... like websockets currently) # https://fastapi.tiangolo.com/advanced/graphql/ router_custom_app.add_route("/graphql", GraphQLApp(schema=graphene.Schema(query=Query))) @router_custom_app.get("/ext-db", tags=["api_custom_app"]) async def ext_db(): result = get_db().execute("select * from books") names = [row[1] for row in result] print(names) return {"Where": "ext-db", "test": names} @router_custom_app.get("/ext-spawn", tags=["api_custom_app"]) async def ext_spawn(): spawn_path = set_model_path("run_model.py") subprocess.Popen( ["python", spawn_path], # program and arguments
"""Main module for the API app.""" import graphene # type: ignore from fastapi import FastAPI from starlette.graphql import GraphQLApp from graphql.execution.executors.asyncio import AsyncioExecutor import schema app = FastAPI() app.add_route( "/", GraphQLApp(schema=graphene.Schema(query=schema.Query), executor_class=AsyncioExecutor))
def test_graphiql_not_found(): app = GraphQLApp(schema=schema, graphiql=False) client = TestClient(app) response = client.get("/", headers={"accept": "text/html"}) assert response.status_code == 404 assert response.text == "Not Found"
class Query(graphene.ObjectType): hello = graphene.String(name=graphene.String(default_value="stranger")) whoami = graphene.String() def resolve_hello(self, info, name): return "Hello " + name def resolve_whoami(self, info): return ("a mystery" if info.context["request"]["user"] is None else info.context["request"]["user"]) schema = graphene.Schema(query=Query) app = GraphQLApp(schema=schema, graphiql=True) client = TestClient(app) def test_graphql_get(): response = client.get("/?query={ hello }") assert response.status_code == 200 assert response.json() == {"data": {"hello": "Hello stranger"}} def test_graphql_post(): response = client.post("/?query={ hello }") assert response.status_code == 200 assert response.json() == {"data": {"hello": "Hello stranger"}}
print(".................................................") if gremlin_server_url is None: print( "ERROR: GREMLIN_SERVER_URL environment variable not set. Please fix it ." ) print( "Exiting the program now. Please refer the documentation at https://github.com/invanalabs/invana-engine" ) exit() routes = [ Route('/', endpoint=homepage_view), Route( '/graphql', GraphQLApp(schema=Schema(query=GremlinQuery, mutation=GremlinMutation), )) ] middleware = [ Middleware(CORSMiddleware, allow_origins=['*'], allow_methods=["GET", "POST", "PUT", "DELETE"]) ] app = Starlette(routes=routes, middleware=middleware, debug=shall_debug) time.sleep(1) gremlin_client = InvanaEngineClient( gremlin_server_url=gremlin_server_url, gremlin_server_username=gremlin_server_username, gremlin_server_password=gremlin_server_password, )
def add_graphql_route(self, path: str, schema: typing.Any, executor: typing.Any = None) -> None: route = GraphQLApp(schema=schema, executor=executor) self.add_route(path, route, methods=["GET", "POST"])
app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) app.mount( '/static', StaticFiles(directory='static'), name='static' ) app.mount( "/graphql", GraphQLApp(schema=schema, executor_class=AsyncioExecutor) ) @app.route("/") async def index(request): servers = [] for server in getServers(): servers.append({"name": server.name}) return templates.TemplateResponse( 'index.html', { 'request': request, "servers": servers } )
app = FastAPI() @app.on_event("startup") async def startup(): await database.connect() @app.on_event("shutdown") async def shutdown(): await database.disconnect() class Places(gp.ObjectType): async_places = gp.String(description='places', start_date=gp.DateTime(), end_date=gp.DateTime()) async def resolve_async_places(self, info, start_date, end_date): print(start_date) print(end_date) rows = await database.fetch_all( query= '''SELECT * FROM places where last_review >= :start_date AND last_review < :end_date''' ) print(rows) return "xd" app.add_route("/", GraphQLApp(schema=gp.Schema(query=Places)))
libData = getLibraryInfo(name) return Library(libData["name"], libData["keywords"], libData["description"], libData["license"], libData["homepage"]) app = FastAPI() templates = Jinja2Templates(directory='static/') @app.get("/") def read_root(request: Request): #return {"Hello": "World"} return templates.TemplateResponse('index.html', context={'request': request}) @app.get("/getinfo/") def read_item(): return "GraphQL endpoint to return data" ''' @app.get("/graphiql") def get_graphiql(): return GraphQLApp(schema=graphene.Schema(query=Query)) ''' app.add_route("/graphiql", GraphQLApp(schema=graphene.Schema(query=Query, types=[Library])))
def resolve_entry(self, info, entry_id): return client.entry(entry_id) def resolve_entries(self, info, skip: Optional[int] = 0, limit: Optional[int] = 30): return sorted(blog.items(skip, limit) + qiita.items(skip, limit), key=lambda x: x.get("published_at"), reverse=True) app = FastAPI() app.add_middleware(GZipMiddleware) app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=False, allow_methods=["*"], allow_headers=["*"], ) app.add_route( "/api", GraphQLApp( schema=graphene.Schema(query=Query, types=[BlogEntry, ExternalEntry]))) @app.options("/api/cors") def api_cors(): return {"status": "ok"}
name=graphene.String(default_value="stranger")) familia = graphene.List(ElementoQL, name=graphene.String(default_value="stranger")) def resolve_elemento(parent, info, name): """Função que retorna os dados da querie de elemento.""" resultado = find_nome(retornaChave(name), app.elementos) return buscaElemento_Nome(resultado) def resolve_sigla(parent, info, name): """Função que retorna os dados da querie de sigla.""" resultado = find_sigla(retornaChave(name), app.elementos) return buscaElemento_Sigla(resultado) def resolve_familia(parent, info, name): """Função que retorna os dados da querie de familia.""" lista = list() [lista.append(elemento) for elemento in buscaElemento_Familia(name)] return lista app.add_route( '/graphql', GraphQLApp(schema=graphene.Schema(query=Query, auto_camelcase=False))) @app.get('/') async def search_elements(request: Request): print(local_directory) return templates.TemplateResponse('index.html', {'request': request})
'http://moviestar-dashboard.herokuapp.com', 'https://moviestar-dashboard.herokuapp.com', 'localhost:3000', 'http://localhost:3000' ] app.add_middleware( CORSMiddleware, allow_origins=origins, allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) app.add_route( "/movies", GraphQLApp(schema=Schema(query=MovieQuery, mutation=MovieMutation), executor_class=AsyncioExecutor)) # app.add_route("/genres", GraphQLApp( # schema=Schema(query=GenreQuery, mutation=GenreMutation), # executor_class=AsyncioExecutor # )) app.add_route( "/calculations", GraphQLApp(schema=Schema(query=CalculationQuery, mutation=CalculationMutation), executor_class=AsyncioExecutor)) app.add_route( "/people", GraphQLApp(schema=Schema(query=PeopleQuery, mutation=PersonMutations),
import graphene from graphql.execution.executors.asyncio import AsyncioExecutor from starlette.applications import Starlette from starlette.graphql import GraphQLApp from starlette.middleware.cors import CORSMiddleware from blenheim.schema.schema import Query, Mutations from blenheim.schema.settings.settings import SettingsMutations app = Starlette() app.add_middleware(CORSMiddleware, allow_origins=['*'], allow_headers=['*'], allow_methods=["POST"]) # noinspection PyTypeChecker app.add_route( '/graphql', GraphQLApp(schema=graphene.Schema(query=Query, mutation=Mutations), executor_class=AsyncioExecutor))
redoc_url=f"{ProjectSettings.API_VERSION_PATH}/redoc") # Middleware Settings app.add_middleware( CORSMiddleware, allow_origins=ProjectSettings.BACKEND_CORS_ORIGINS, allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # Routes # app.include_router(api_router) # app.add_route(f"{ProjectSettings.API_VERSION_PATH}/graphql", GraphQLApp( # schema=graphene.Schema(query=Query, mutation=Mutations))) graphql_app = GraphQLApp(schema=Schema(query=Query, mutation=Mutations)) @app.api_route(f"{ProjectSettings.API_VERSION_PATH}/graphql", methods=["GET", "POST"]) async def graphql(request: Request, current_user: schemas.UserVerify = Depends( deps.get_current_user)): """ FastAPI-GraphQL with JWT Authentication """ return await graphql_app.handle_graphql(request=request) app.include_router(api_router, prefix=ProjectSettings.API_VERSION_PATH)
import graphene from starlette.graphql import GraphQLApp from starlette.routing import Mount, Route, Router from example.views import Homepage from example.queries import QueryAPI router = Router([ Route("/", endpoint=Homepage, methods=["GET"]), Route("/graph/v1/", endpoint=GraphQLApp(schema=graphene.Schema(query=QueryAPI))), ])
return AddTask(ok=True, task=task) class DeleteTask(graphene.Mutation): class Arguments: idx = graphene.ID() ok = graphene.Boolean() task = graphene.Field(lambda: Task) def mutate(parent, info, idx): task = manager.delete_task(idx) return AddTask(ok=True, task=task) class RootMutation(graphene.ObjectType): add_task = AddTask.Field() edit_task = EditTask.Field() delete_task = DeleteTask.Field() app = FastAPI() app.add_route( "/", GraphQLApp(schema=graphene.Schema(query=RootQuery, mutation=RootMutation))) # Run: # uvicorn main:app --reload # Visit: # http://127.0.0.1:8000/
from fastapi import FastAPI from starlette.graphql import GraphQLApp from schema import schema app = FastAPI() app.add_route("/", GraphQLApp(schema=schema, graphiql=True))
import graphene from fastapi import FastAPI from starlette.graphql import GraphQLApp from graphene_sqlalchemy import SQLAlchemyObjectType, SQLAlchemyConnectionField from . import crud, models from .database import engine, SessionLocal models.Base.metadata.create_all(bind=engine) class Song(SQLAlchemyObjectType): class Meta: model = models.Song class Query(graphene.ObjectType): songs = graphene.List(Song) def resolve_songs(self, info): session = info.context.get("session", SessionLocal) return crud.get_all_songs(session) app = FastAPI() schema = graphene.Schema(query=Query) app.add_route("/", GraphQLApp(schema=schema))
def old_style_async_app(event_loop) -> GraphQLApp: old_style_async_app = GraphQLApp( schema=async_schema, executor=AsyncioExecutor(loop=event_loop), ) return old_style_async_app