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
