def get_test_app():
app = Flask(__name__)
app.debug = True
app.add_url_rule('/graphql', 'graphql', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True))
app.add_url_rule('/', 'index', view_func=index_view,)
return app
def register_blueprints(app):
for name in find_modules('blog.views'):
mod = import_string(name)
if hasattr(mod, 'bp'):
app.register_blueprint(mod.bp)
app.add_url_rule('/graphql', view_func=GraphQLView.as_view(
'graphql', schema=schema, graphiql=True))
def create_app():
app = Flask(__name__)
app.add_url_rule(
'/sale_point',
view_func=GraphQLView.as_view(
'sale_point',
schema=sale_point_schema,
graphiql=True
)
)
return app
# config.read('o11y.ini')
# beeline.init(writekey=config['DEFAULT']['honeycomb_key'], dataset='RPG Simulation', service_name='graghql_backend')
app = Flask(__name__)
# if path.exists():
# # db_events defaults to True, set to False if not using our db middleware with Flask-SQLAlchemy
# HoneyMiddleware(app, db_events=True)
app.debug = True
app.add_url_rule(
'/graphql',
view_func=GraphQLView.as_view(
'graphql',
schema=schema,
graphiql=True # for having the GraphiQL interface
))
# /graphql-mutation
app.add_url_rule('/createCharacter',
view_func=GraphQLView.as_view('create-character',
schema=schema_mutation,
graphiql=True))
@app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
def task_detail_wrapper():
view = GraphQLView.as_view("task_detail",
schema=graphene.Schema(query=TaskDetailQuery),
graphiql=True)
return sensible_token(view)
#!/usr/bin/env bash
import pytest
from flask_graphql import GraphQLView
from flask_graphql_auth import GraphQLAuth
from flask_migrate import MigrateCommand
from flask_script import Manager, Server
from app import create_app, db
from app.schema import schema
app = create_app()
auth = GraphQLAuth(app)
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view('graphql',
schema=schema,
graphiql=True))
manager = Manager(app, db)
manager.add_command('db', MigrateCommand)
manager.add_command('server', Server)
if __name__ == '__main__':
manager.run()
##
from flask import Flask, send_from_directory, make_response, send_file
from flask_graphql import GraphQLView
from .schema import schema
from zeromq import ZeroClient
from os import getcwd
# Instancia
apiServer = Flask(__name__)
#GraphQL
apiServer.add_url_rule('/graphqlTesting',
view_func=GraphQLView.as_view(
'graphqlTesting',
schema=schema,
graphiql=True,
context={'aggClient': ZeroClient('apiServer')}))
# Screenshoty z testov
@apiServer.route('/screenshot/<path:path>')
def screenshotResult(path):
return send_from_directory('../screenshot/', path)
# Generovane klientske skripty
@apiServer.route('/client/<file>')
def clientScript(file):
response = make_response(send_file('../client/' + file))
response.headers[
from flask import jsonify, Blueprint, request
from flask_login import login_required, current_user
from flask_graphql import GraphQLView
from rr.db import db
import rr.queries as q
import rr.jobs as jobs
import rr.events as e
from rr.schema import schema
routes = Blueprint('routes', __name__)
# Optional, for adding batch query support (used in Apollo-Client)
routes.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True))
@routes.route('/prompts')
def prompt():
prompts = q.get_prompts()
return jsonify(
{prompt.date.isoformat(): prompt
for prompt in prompts.all()})
@routes.route('/compositions', methods=['POST'])
@login_required
def create_composition_route():
payload = request.json
composition = q.create_composition(
prompt_id=payload['prompt_id'],
from schema import schema
from template import render_graphiql
app = Flask(__name__)
app.debug = True
sockets = Sockets(app)
@app.route("/graphiql")
def graphql_view():
return make_response(render_graphiql())
app.add_url_rule(
"/graphql", view_func=GraphQLView.as_view("graphql", schema=schema, graphiql=False)
)
subscription_server = GeventSubscriptionServer(schema)
app.app_protocol = lambda environ_path_info: "graphql-ws"
@sockets.route("/subscriptions")
def echo_socket(ws):
subscription_server.handle(ws)
return []
if __name__ == "__main__":
from gevent import pywsgi
from geventwebsocket.handler import WebSocketHandler
DOCKER_SOCK = str(cf.get('docker', 'sockpath'))
MAX_LIFE = int(cf.get('docker', 'maxlife'))
PASSWD = str(cf.get('docker', 'password'))
#threadPool = ThreadPoolExecutor(max_workers=MAX_CONTAINER)
session = sqlsession.session
models.Base.metadata.create_all(sqlsession.engine)
app = Flask(__name__)
cors = CORS(app)
webhook = Webhook(app) # Defines '/postreceive' endpoint
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view(
'graphql',
schema=schema.dataschema,
graphiql=True,
get_context=lambda: {'session': session}))
client = docker.Client(base_url=DOCKER_SOCK)
def operate_proj(git, commit, gittime, committer, message):
exist, buildId, projId, name = buildProj.build(git, commit, gittime,
committer, message)
#print(exist,buildId,projId,name)
if exist == True:
pass
else:
print("%s threading is printed %s, %s" %
(threading.current_thread().name, git, commit))
def init_service(service, schema):
""" Add GraphQL support to the given Flask app """
# add default graphql endpoints
GraphQL(service.app, schema=schema)
# add the index query per service agreement
service.app.add_url_rule('/', view_func=GraphQLView.as_view('index', schema=schema))
def init_views():
from photogal.graphql import schema
enable_graphiql = app.env == 'development'
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=enable_graphiql))
app.add_url_rule('/graphql/batch', view_func=GraphQLView.as_view('graphql-batch', schema=schema, batch=True))
def honeycomb_middleware(next, root, info, **args):
with beeline.tracer(name="graphql_execute"):
beeline.add_context({
"graphql.parent_type":
root._meta.name if root and hasattr(root, "_meta") else "",
"graphql.field_name":
info.field_name,
"graphql.args":
args,
})
return next(root, info, **args)
app.add_url_rule(
"/graphql",
view_func=GraphQLView.as_view(
"graphql",
schema=schema,
root_value=splitter,
graphiql=True,
middleware=[honeycomb_middleware],
),
)
atexit.register(beeline.close)
if __name__ == "__main__":
app.run(host="0.0.0.0")
from flask import Flask
from database import db_session
from flask_graphql import GraphQLView
from schema import schema
app = Flask(__name__)
app.debug = True
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True, context={'session': db_session}))
@app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
app.run()
)
GROUP BY
file.project
ORDER BY
total_downloads DESC
LIMIT 250
"""):
p = Package()
p.name = project
p.recent_downloads = downloads
yield p
return list(gen())
schema = graphene.Schema(query=Query)
app.add_url_rule('/',
view_func=GraphQLView.as_view('graphql',
schema=schema,
graphiql=True))
# Optional, for adding batch query support (used in Apollo-Client)
app.add_url_rule('/batch',
view_func=GraphQLView.as_view('graphql_batch',
schema=schema,
batch=True))
if __name__ == '__main__':
# common.serve()
app.run()
): #this is a function that gets called when message property is requested
return 'My first project'
def resolve_name(self, info):
return 'hello'
#gschema=graphene.Schema(query=QuerySample) #create graphene schema(graphql schema) from class QuerySample
# end static query
# Flask Rest & Graphql Routes
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view(
'graphql',
schema=tableSchema,
graphiql=True,
))
@app.route('/')
def root():
return render_template("index.html")
#@app.route('/app.js')
#def script():
# return render_template("app.js")
if __name__ == '__main__':
app.run()
import os
from gevent import monkey
from flask import Flask
from flask_graphql import GraphQLView
from graphql.execution.executors.gevent import GeventExecutor
from graphene import Schema
from schema import Query
monkey.patch_all()
view_func = GraphQLView.as_view('graphql',
schema=Schema(query=Query),
executor=GeventExecutor(),
graphiql=True)
app = Flask(__name__)
app.add_url_rule('/graphql', view_func=view_func)
if __name__ == '__main__':
app.run(host='0.0.0.0', port=os.environ.get('PORT', 5000))
from database.base import db_session
from flask import Flask
from flask_graphql import GraphQLView
from schema import schema
app = Flask(__name__)
app.add_url_rule(
'/graphql',
view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True))
@app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
app.run(threaded=True) # debug=True
def create_graphql_route(app):
app.add_url_rule('/graphql/', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True))
from flask import Flask
from flask_graphql import GraphQLView
from graphene import Schema
from com.tutorial.schema.user import User
view_func = GraphQLView.as_view('graphql', schema=Schema(query=User))
app = Flask(__name__)
app.add_url_rule('/', view_func=view_func)
if __name__ == '__main__':
app.run()
def _add_url_rules(self):
self.blueprint.add_url_rule('/', view_func=self.index_view)
self.blueprint.add_url_rule('/<path:path>', view_func=self.index_view)
self.blueprint.add_url_rule('/graphql',
view_func=GraphQLView.as_view(
'graphql', schema=self.schema))
from flask import Flask, redirect, url_for
from flask_graphql import GraphQLView
from example.database import db_session, init_db
from example.schema import schema
app = Flask(__name__)
app.add_url_rule(
'/graphql', view_func=GraphQLView.as_view(
'graphql',
schema=schema,
graphiql=True,
context={'session': db_session},
))
@app.route('/')
def index():
#return "GraphQL at /graphql"
return redirect(url_for('graphql'))
@app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if '__main__' == __name__:
# for testing purposes
init_db()
app.run(host='0.0.0.0', port=5001, debug=True)
fake = Factory.create()
FIXTURE = Fixture()
with open("./datos/robots.json", "r") as f:
for robot in json.loads(f.read()):
FIXTURE.inscribir_robot(*robot)
SCRAPPER = Robot_scrapper(True)
SCRAPPER.scrap_file()
app = Flask(__name__)
CORS(app)
app.add_url_rule('/fixture', view_func = GraphQLView.as_view('fixture',
schema=schema,
get_context= lambda *args, **kwargs: {"fixture": FIXTURE},
graphiql=True))
@app.route('/')
def index():
return render_template("index.html", robots = len(FIXTURE.robots))
@app.route('/scrapper/<categoria>')
def scrapper(categoria):
equipos = SCRAPPER.get_equipos()
equipos = [equipo for equipo in equipos if equipo.categoria.startswith(categoria)]
FIXTURE.limpiar()
for equipo in equipos:
FIXTURE.inscribir_equipo(equipo)
return redirect("/")
@staticmethod
def resolve_county_wise_current_records(*args):
return (CovidByCountyRecord.query.order_by(
CovidByCountyRecord.date.desc()).limit(15).all())
@staticmethod
def resolve_risk_index_records(*args):
return (RiskIndexRecord.query.order_by(
RiskIndexRecord.created_at.desc(),
RiskIndexRecord.risk_index.desc())
# .limit(537)
.all())
schema = graphene.Schema(query=Query)
backend_application.add_url_rule(
"/graphql-api",
view_func=GraphQLView.as_view("graphql", schema=schema, graphiql=True),
)
# @backend_application.route("/detailed-countries", methods=["GET"])
# def detailed_countries():
# return Response(json.dumps([country.casefold() for country in DETAILED_COUNTRIES]))
@backend_application.route("/<path:filename>", methods=["GET"])
def dev_frontend_test(filename):
return send_from_directory(
directory=f"{BackendSettings.BASE_DIR}/frontend", filename=filename)
def users_view():
view = GraphQLView.as_view('users',
schema=schema2,
graphiql=bool(app.config.get("DEBUG", False)))
view = jwt_required(view)
return view
from flask_restful import Api, Resource
from flask_cors import CORS
from flask_graphql import GraphQLView
from graphene import Schema
from resources.election import ElectionList
from resources.region import RegionList
from resources.constituency import Constituency
from resources.candidate import Candidate
from graphql_api.schema import Query
import tenderServiceRunner
TENDER_DATA_FILE = 'common/dataSource/rawData/tenderRepository'
tenderServiceRunner.initTenderService(TENDER_DATA_FILE)
app = Flask(__name__)
api = Api(app)
CORS(app)
api.add_resource(ElectionList, '/elections')
api.add_resource(RegionList, '/<string:electionName>/<int:year>/regions')
api.add_resource(
Constituency,
'/<string:electionName>/<int:year>/constituencies/<string:id>')
api.add_resource(Candidate,
'/<string:electionName>/<int:year>/candidates/<int:id>')
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view('graphql',
schema=Schema(Query),
graphiql=True))
def get_app():
"""Returns a Flask application object
The rules are maintained in the ROUTES variable (Note: By default a rule just listens for GET)
CORS is used to allow CORS for all domains on all routes
:return: a Flask application object
"""
connect()
graphql = GraphQLView.as_view(
'graphql',
schema=schema,
graphiql=True # for having the GraphiQL interface
)
graphql_streaming = GraphQLStreamingApi()
app = Flask(__name__)
CORS(app)
# Exclude all non-secure urls fot the audit log and provide the callable to get the user from the request
app.config['AUDIT_LOG'] = {
'EXEMPT_URLS': [fr'^(?!{API_SECURE_BASE_PATH}).+'],
'LOG_HANDLER_CALLABLE_PATH':
'gobapi.util.audit_log.get_log_handler',
'USER_FROM_REQUEST_CALLABLE_PATH':
'gobapi.util.audit_log.get_user_from_request',
}
# Add the AuditLogMiddleware
AuditLogMiddleware(app)
# Health check route
app.route(rule='/status/health/')(_health)
# Application routes
PUBLIC = [API_BASE_PATH, API_SECURE_BASE_PATH]
# SECURE = [API_SECURE_BASE_PATH]
ROUTES = [
(PUBLIC, '/', _catalogs, ['GET']),
(PUBLIC, '/<catalog_name>/', _catalog, ['GET']),
(PUBLIC, '/<catalog_name>/<collection_name>/', _collection, ['GET']),
(PUBLIC, '/<catalog_name>/<collection_name>/<entity_id>/', _entity,
['GET']),
(PUBLIC,
'/<catalog_name>/<collection_name>/<entity_id>/<reference_path>/',
_reference_collection, ['GET']),
(PUBLIC, '/alltests/', _clear_tests, ['DELETE']),
(PUBLIC, '/toestanden/', _states, ['GET']),
(PUBLIC, '/graphql/', graphql, ['GET', 'POST']),
(PUBLIC, '/graphql/streaming/', graphql_streaming.entrypoint, ['POST'
]),
(PUBLIC, '/dump/<catalog_name>/<collection_name>/', _dump,
['GET', 'POST']),
(PUBLIC, '/worker/<worker_id>', worker_result, ['GET']),
(PUBLIC, '/worker/end/<worker_id>', worker_end, ['DELETE']),
(PUBLIC, '/worker/status/<worker_id>', worker_status, ['GET']),
(PUBLIC, '/fat_file/<gbs>', fat_file, ['GET']),
(PUBLIC, '/info/<info_type>/', get_db_info, ['GET'])
]
for paths, rule, view_func, methods in ROUTES:
_add_route(app, paths, rule, view_func, methods)
app.teardown_appcontext(shutdown_session)
return app
name,
balanceValue,
meta {
profile {
profileImage
}
}
},
votes(first: 10) {
edges {
node {
voter {
name,
}
}
}
}
}
}
""".strip()
schema = graphene.Schema(query=query.Queries)
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql',
schema=schema,
graphiql=True,
query=default_query))
if __name__ == '__main__':
app.run()
@application.teardown_appcontext
def shutdown_session(exception=None):
session.remove()
@application.route("/", defaults={"path": ""})
@application.route("/<path:path>")
def serve(path):
if path != "" and os.path.exists(application.static_folder + "/" + path):
return send_from_directory(application.static_folder, path)
else:
print(application.static_folder)
return send_from_directory(application.static_folder, "index.html")
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--interactive-graphql", action="store_true")
arguments = parser.parse_args()
application.add_url_rule(
"/graphql",
view_func=GraphQLView.as_view("graphql",
schema=schema,
graphiql=arguments.interactive_graphql),
)
application.run()
return jsonify({"user": {"token": tok}}), 200
except Exception as e:
return jsonify({"errors": {"global": str(e)}}), 200
def f():
if True:
return
return
app.add_url_rule('/graphiql',
view_func=requires_auth(
GraphQLView.as_view('graphiql',
schema=schema,
graphiql=True)))
app.add_url_rule('/graphql',
view_func=token_auth.login_required(
GraphQLView.as_view('graphql',
schema=schema,
graphiql=False)))
@app.route("/about")
def about():
return render_template('about.html')
@app.route("/")
def home():
from flask import Flask, escape, request
from flask_pymongo import PyMongo
from dotenv import load_dotenv
from flask_graphql import GraphQLView
from graphene import Schema
from resolvers import Query
from flask_cors import CORS
load_dotenv()
app = Flask(__name__)
CORS(app)
view_func = GraphQLView.as_view("/graphql", schema=Schema(query=Query))
app.add_url_rule("/graphql", view_func=view_func)
@app.route('/')
def index():
return "GraphQL server is listening on /graphql"
if __name__ == "__main__":
app.run()
from flask import Flask
from flask_debugtoolbar import DebugToolbarExtension
from flask_graphql import GraphQLView
from models import db_session
from schema import schema
app = Flask(__name__)
app.debug = True
app.config['SECRET_KEY'] = 'SECRET'
toolbar = DebugToolbarExtension(app)
app.add_url_rule(
'/graphql',
view_func=GraphQLView.as_view(
'graphql',
schema=schema,
graphiql=True # for having the GraphiQL interface
))
@app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
app.run()
from flask import Flask
from flask_graphql import GraphQLView as View
from database import db_session
from graph_ql.schema import schema
app = Flask(__name__)
app.debug = True
app.add_url_rule("/",
view_func=View.as_view("graphql",
graphiql=True,
schema=schema))
@app.teardown_appcontext
def shutdown_session(Error=None):
db_session.remove()
def main():
app.run()
if __name__ == "__main__":
main()
def create_app(path='/graphql', **kwargs):
app = Flask(__name__)
app.debug = True
app.add_url_rule(path, view_func=GraphQLView.as_view('graphql', schema=Schema, graphiql=True))
return app
else:
helpers.set_mode('easy')
else:
if session.get('difficulty') == None:
helpers.set_mode('easy')
schema = graphene.Schema(query=Query, mutation=Mutations)
gql_middlew = [
middleware.CostProtectionMiddleware(),
middleware.DepthProtectionMiddleware(),
middleware.IntrospectionMiddleware(),
middleware.processMiddleware()
]
igql_middlew = [middleware.IGQLProtectionMiddleware()]
app.add_url_rule('/graphql',
view_func=GraphQLView.as_view('graphql',
schema=schema,
middleware=gql_middlew,
batch=True))
app.add_url_rule('/graphiql',
view_func=GraphQLView.as_view('graphiql',
schema=schema,
graphiql=True,
middleware=igql_middlew,
batch=True))
from flask import Flask, send_from_directory
from flask_cors import CORS
from flask_graphql import GraphQLView
from db.models import db_session
from interfaces import discover, playlists
app = Flask(__name__)
app.debug = True
CORS(app)
app.add_url_rule(
'/discover/graphql',
view_func=GraphQLView.as_view('discover_graphql', schema=discover.schema, graphiql=True)
)
app.add_url_rule(
'/playlists/graphql',
view_func=GraphQLView.as_view('playlists_graphql', schema=playlists.schema, graphiql=True)
)
@app.route('/client/<path:filename>')
def serve_static(filename):
return send_from_directory("client/", filename)
@app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
import graphene
import os
import json
from flask import Flask, url_for, redirect, request
from flask_graphql import GraphQLView
from query import Query, query_url
from OpenSSL import SSL
from graphql import GraphQLError
app = Flask(__name__)
view_func = GraphQLView.as_view('graphql',
schema=graphene.Schema(query=Query),
graphiql=True)
app.add_url_rule('/graphql', view_func=view_func)
@app.route("/", methods=['GET'])
def hello():
return redirect(url_for('static', filename='index.html'))
@app.route("/graphQL", methods=['GET'])
def queryURL():
url = request.args.get('url')
if url != None and url != '' and url != ' ':
try:
reg = query_url(url, Query)
if reg == 'null':
# print('reg is ' + reg)
return 'url is invalid, please provide valid url'
return reg
# flask_sqlalchemy/app.py
from flask import Flask
from flask_graphql import GraphQLView
from models import db_session
from schema import schema, Department
app = Flask(__name__)
app.debug = True
app.add_url_rule(
'/graphql',
view_func=GraphQLView.as_view(
'graphql',
schema=schema,
graphiql=True # for having the GraphiQL interface
)
)
@app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
app.run()
# Copyright 2019 Axis Communications AB.
#
# For a full list of individual contributors, please see the commit history.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from flask import Flask
from flask_graphql import GraphQLView
from .schemas.schema import SCHEMA
APP = Flask(__name__)
APP.add_url_rule("/graphql", view_func=GraphQLView.as_view('graphql', schema=SCHEMA, graphiql=True))
default_query = '''
{
allEmployees {
edges {
node {
id,
name,
department {
id,
name
},
role {
id,
name
}
}
}
}
}'''.strip()
app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=True))
@app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
init_db()
app.run()
def _add_url_rules(self):
self.blueprint.add_url_rule('/', view_func=self.index_view)
self.blueprint.add_url_rule('/<path:path>', view_func=self.index_view)
self.blueprint.add_url_rule(
'/graphql', view_func=GraphQLView.as_view(
'graphql', schema=self.schema))
