from flask import Flask
from flask_jsonrpc import JSONRPC
from flask_cors import CORS
from flask_socketio import SocketIO
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../'))
from superai.common import InitLog
from superai.sysmonitor import sysFlushThread, cpuFlushStop, \
getCpuResult, getSysversionResult, getMemResult, getDiskResult, getNetworkResult
from superai.subnodedb import DbEventSelect, DbStateSelect, DbItemSelect, DbStateGetNearestTimepoint
app = Flask(__name__)
CORS(app)
jsonrpc = JSONRPC(app, '/api', enable_web_browsable_api=True)
socketio = SocketIO(app, cors_allowed_origins='*', async_mode='gevent')
@app.route('/')
def test():
return 'subnodeapi'
# jsonprc 事件
@jsonrpc.method('getEvent')
def getEvent():
rows = DbEventSelect()
jsonstr = json.dumps(rows, ensure_ascii=False)
return jsonstr
import os
from optparse import OptionParser
import json
from flask import Flask, jsonify
from flask_jsonrpc import JSONRPC
# third party modules
# local modules
__author__ = "Johnny Mariethoz <*****@*****.**>"
__version__ = "0.0.0"
__copyright__ = "Copyright (c) 2009-2015 Rero, Johnny Mariethoz"
__license__ = "Internal Use Only"
jsonrpc = JSONRPC(service_url="/rpc")
@jsonrpc.method("api.get_udc")
def get_udc(lang):
from rerodoc.udc.udc import get_long_names
return get_long_names(lang).values()
app = Flask(__name__)
@app.route("/angular/<doc_type>/edit/<recid>")
def edit_angular(doc_type, recid):
from rerodoc.dojson.utils import get_schema, get_form
from flask import Flask
PROJECT_DIR, PROJECT_MODULE_NAME = os.path.split(
os.path.dirname(os.path.realpath(__file__))
)
FLASK_JSONRPC_PROJECT_DIR = os.path.join(PROJECT_DIR, os.pardir)
if os.path.exists(FLASK_JSONRPC_PROJECT_DIR) \
and not FLASK_JSONRPC_PROJECT_DIR in sys.path:
sys.path.append(FLASK_JSONRPC_PROJECT_DIR)
from flask_jsonrpc import JSONRPC
from flask_jsonrpc.site import JSONRPCSite
app = Flask(__name__)
jsonrpc_v1 = JSONRPC(app, '/api/v1', site=JSONRPCSite(), enable_web_browsable_api=True)
jsonrpc_v2 = JSONRPC(app, '/api/v2', site=JSONRPCSite(), enable_web_browsable_api=True)
@jsonrpc_v1.method('App.index')
def index_v1():
return u'Welcome to Flask JSON-RPC Version API 1'
@jsonrpc_v2.method('App.index')
def index_v2():
return u'Welcome to Flask JSON-RPC Version API 2'
if __name__ == '__main__':
app.run(host='0.0.0.0', debug=True)
from flask import Flask, request, json
PROJECT_DIR, PROJECT_MODULE_NAME = os.path.split(
os.path.dirname(os.path.realpath(__file__)))
FLASK_JSONRPC_PROJECT_DIR = os.path.join(PROJECT_DIR, os.pardir)
if os.path.exists(FLASK_JSONRPC_PROJECT_DIR) \
and not FLASK_JSONRPC_PROJECT_DIR in sys.path:
sys.path.append(FLASK_JSONRPC_PROJECT_DIR)
from flask_jsonrpc import JSONRPC, make_response
from flask_jsonrpc.exceptions import OtherError
app = Flask(__name__)
jsonrpc = JSONRPC(app, '/api')
def check_terminal_id(fn):
def wrapped(*args, **kwargs):
terminal_id = int(request.get_json(silent=True).get('terminal_id', 0))
if terminal_id <= 0:
raise OtherError('Invalid terminal ID')
rv = fn(*args, **kwargs)
return rv
return wrapped
def jsonrcp_headers(fn):
def wrapped(*args, **kwargs):
from flask import Flask,Response
from flask_jsonrpc import JSONRPC
import json
import time
import psutil
import dicttoxml
app = Flask(__name__)
jsonrpc = JSONRPC(app, '/')
@jsonrpc.method('time')
def get_time():
t_json = {
"time" : int(time.time())
}
format = json.dumps(t_json)
return Response(
response= format,
mimetype="application/json",
status=200
)
@jsonrpc.method('ram')
def get_ram():
r_json = {
"total" : int((psutil.virtual_memory().total/1024)/1024),
"used" : int((psutil.virtual_memory().used/1024)/1024)
}
format = json.dumps(r_json)
return Response(
response=format,
from flask_sqlalchemy import SQLAlchemy
from app.config import ProductionConfig, TestingConfig
#from authlib.flask.client import OAuth
from flask_jsonrpc import JSONRPC
from werkzeug.contrib.cache import MemcachedCache
from werkzeug.contrib.cache import SimpleCache
from flask_caching import Cache
from werkzeug.contrib.profiler import ProfilerMiddleware
from flask_migrate import Migrate, MigrateCommand
app = Flask(__name__)
cors = CORS(app)
#cache = Cache(app, config={'CACHE_TYPE': 'simple'})
#app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[30])
isonrpc = JSONRPC(app, '/api/')
app.config.from_object(ProductionConfig)
#app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://ekaterina:@localhost/track_orm'
#oauth = OAuth(app)
#app.config.from_object(TestingConfig)
#app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://*****:*****@89.208.84.222/quack'
db = SQLAlchemy(app)
migrate = Migrate(db)
#cache = MemcachedCache(['127.0.0.1:11211'])
from .views import *
#from .handlers_old import *
from app import model
#from .task import *
def sendRequest(self, service_name, params):
"""
请求数据
:param service_name: 数据服务名字
:param params: 查询参数
:return: 返回数据
"""
# print("sendRequest")
return json.loads(
DataServiceJavaProxy._DataServiceInstance.sendRequest(
service_name, json.dumps(params)))
data_access_app = Flask("data_access")
jsonrpc = JSONRPC(data_access_app)
@jsonrpc.method("api.index")
def index():
return f"index"
@jsonrpc.method('api.sendRequest')
def sendRequest(service_name, params):
"""
请求数据
:param service_name: 数据服务名字
:param params: 查询参数
:return: 返回数据
class AuthorizationView(JSONRPCView):
def check_auth(self) -> bool:
username = request.headers.get('X-Username')
password = request.headers.get('X-Password')
return username == 'username' and password == 'secret'
def dispatch_request(self):
if not self.check_auth():
raise UnauthorizedError()
return super(AuthorizationView, self).dispatch_request()
app = Flask(__name__)
jsonrpc = JSONRPC(app, '/api', jsonrpc_site_api=AuthorizationView)
@jsonrpc.method('App.index')
def index() -> str:
return 'Welcome to Flask JSON-RPC'
@jsonrpc.method('App.echo')
def echo(name: str = 'Flask JSON-RPC') -> str:
return 'Hello {0}'.format(name)
if __name__ == '__main__':
app.run(host='0.0.0.0', debug=True)
from flask import Flask
from src.predict import predict
from flask_jsonrpc import JSONRPC
from typing import Dict, List
app = Flask(__name__)
jsonrpc = JSONRPC(app, '/', enable_web_browsable_api=False)
@jsonrpc.method('process')
def process_text(text: str) -> List[Dict]:
text = predict(text)
return text
if __name__ == '__main__':
app.run()
try:
from uwsgi import cache_get, cache_set
except:
def cache_get(*f):
return None
def cache_set(*f):
return None
app = Flask(__name__)
jsonrpc = JSONRPC(app,
'/api',
enable_web_browsable_api=False,
site=jsonrpc_site)
@app.route('/api/healthcheck')
def healthcheck():
fe_status_cached = cache_get('gbix_healthcheck',
cache_options['default']['name'])
if fe_status_cached:
return fe_status_cached
else:
try:
fe_status = fowardZ.sendRequest('{"jsonrpc": "2.0", \
"method": "apiinfo.version", \
# isort:skip_file
import os
import sys
from flask import Flask, render_template
PROJECT_DIR, PROJECT_MODULE_NAME = os.path.split(
os.path.dirname(os.path.realpath(__file__)))
FLASK_JSONRPC_PROJECT_DIR = os.path.join(PROJECT_DIR, os.pardir)
if os.path.exists(FLASK_JSONRPC_PROJECT_DIR
) and FLASK_JSONRPC_PROJECT_DIR not in sys.path:
sys.path.append(FLASK_JSONRPC_PROJECT_DIR)
from api.hello import hello # noqa: E402 pylint: disable=C0413
from flask_jsonrpc import JSONRPC # noqa: E402 pylint: disable=C0413
app = Flask(__name__)
app.config.from_object(__name__)
jsonrpc = JSONRPC(app, '/api')
jsonrpc.register_blueprint(app, hello, url_prefix='/hello')
@app.route('/')
def index():
return render_template('index.html')
if __name__ == '__main__':
app.run(host='0.0.0.0', debug=True)
def create_app(test_config=None): # noqa: C901 pylint: disable=W0612
"""Create and configure an instance of the Flask application."""
app = Flask(__name__, instance_relative_config=True)
if test_config:
app.config.update(test_config)
jsonrpc = JSONRPC(app, '/api', enable_web_browsable_api=True)
# pylint: disable=W0612
@jsonrpc.method('jsonrpc.greeting')
def greeting(name: str = 'Flask JSON-RPC') -> str:
return 'Hello {0}'.format(name)
# pylint: disable=W0612
@jsonrpc.method('jsonrpc.echo')
def echo(string: str, _some: Any = None) -> str:
return string
# pylint: disable=W0612
@jsonrpc.method('jsonrpc.notify')
def notify(_string: str = None) -> None:
pass
# pylint: disable=W0612
@jsonrpc.method('jsonrpc.fails')
def fails(n: int) -> int:
if n % 2 == 0:
return n
raise ValueError('number is odd')
# pylint: disable=W0612
@jsonrpc.method('jsonrpc.strangeEcho')
def strangeEcho(string: str,
omg: Dict[str, Any],
wtf: List[str],
nowai: int,
yeswai: str = 'Default') -> List[Any]:
return [string, omg, wtf, nowai, yeswai]
# pylint: disable=W0612
@jsonrpc.method('jsonrpc.sum')
def sum_(a: Union[int, float], b: Union[int, float]) -> Union[int, float]:
return a + b
# pylint: disable=W0612
@jsonrpc.method('jsonrpc.decorators')
@jsonrcp_decorator
def decorators(string: str) -> str:
return 'Hello {0}'.format(string)
# pylint: disable=W0612
@jsonrpc.method('jsonrpc.returnStatusCode')
def return_status_code(s: str) -> Tuple[str, int]:
return 'Status Code {0}'.format(s), 201
# pylint: disable=W0612
@jsonrpc.method('jsonrpc.returnHeaders')
def return_headers(s: str) -> Tuple[str, Dict[str, Any]]:
return 'Headers {0}'.format(s), {'X-JSONRPC': '1'}
# pylint: disable=W0612
@jsonrpc.method('jsonrpc.returnStatusCodeAndHeaders')
def return_status_code_and_headers(
s: str) -> Tuple[str, int, Dict[str, Any]]:
return 'Status Code and Headers {0}'.format(s), 400, {'X-JSONRPC': '1'}
class_app = App()
jsonrpc.register(class_app.index, name='classapp.index')
jsonrpc.register(class_app.greeting)
jsonrpc.register(class_app.hello)
jsonrpc.register(class_app.echo)
jsonrpc.register(class_app.notify)
jsonrpc.register(class_app.fails)
return app
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE."""
from flask import Flask, request
from flask_jsonrpc import JSONRPC
from proxy.state import State
from channel_manager.state import ChannelAddress
from exception import ChannelDBAddFail
from channel_manager import manager
from flask_cors import CORS
from logzero import logger
app = Flask(__name__)
cors = CORS(app, support_credentials=True)
jsonrpc = JSONRPC(app, "/")
@jsonrpc.method("registeaddress")
def regist_address(address, port = "20556"):
logger.info("registeaddress %s" %address)
ip_info = request.headers.getlist("X-Forwarded-For")[0] if request.headers.getlist("X-Forwarded-For") \
else request.remote_addr
channel_address = ChannelAddress()
try:
channel_address.add_address(address, ip=ip_info, port= port)
except ChannelDBAddFail:
channel_address.delete_address(address)
return State.raise_fail(101, "Can Not Add The Address")
return State.success()
