def start(self):
default_app = Starlette()
@default_app.route("/{actor}", methods=["GET", "POST"])
async def dispatch_remote_function(request):
data = await request.json()
actor_name = request.path_params["actor"]
slo_seconds = data.pop("slo_ms") / 1000
deadline = time.perf_counter() + slo_seconds
inp = data.pop("input")
result_future = unwrap(
self.router.call.remote(actor_name, inp, deadline))
# TODO(simon): change to asyncio ray.get
result = ray.get(result_future)
return JSONResponse({
"success": True,
"actor": actor_name,
"result": result
})
uvicorn.run(default_app, host=self.ip, port=self.port)
def main(app=None):
# setup
if app is None:
app = init()
kwargs = {}
if LOCAL_DEV:
kwargs['reload'] = True
else:
kwargs['workers'] = 2
uvicorn.run(app, host='0.0.0.0', http='h11', port=8445, headers=[('Server', 'tmeister')],
proxy_headers=True, **kwargs)
data_bunch = ImageDataBunch.single_from_classes(
path, classes, tfms=get_transforms(),
size=224).normalize(imagenet_stats)
learn = cnn_learner(data_bunch, models.resnet34, pretrained=False)
learn.load(model_file_name)
return learn
loop = asyncio.get_event_loop()
tasks = [asyncio.ensure_future(setup_learner())]
learn = loop.run_until_complete(asyncio.gather(*tasks))[0]
loop.close()
@app.route('/')
def index(request):
html = path / 'view' / 'index.html'
return HTMLResponse(html.open().read())
@app.route('/analyze', methods=['POST'])
async def analyze(request):
data = await request.form()
img_bytes = await (data['file'].read())
img = open_image(BytesIO(img_bytes))
return JSONResponse({'result': learn.predict(img)[0]})
if __name__ == '__main__':
if 'serve' in sys.argv: uvicorn.run(app, host='0.0.0.0', port=8080)
pattern = '(?:{})(.*)(?:{})'.format(prepend_esc, eot_esc)
trunc_text = re.search(pattern, text).group(1)
valid_card_text = await is_ascii(trunc_text)
# ensure there is only one of each section in the generated card
counts = Counter(trunc_text)
section_ids = ['0', '1', '3', '4', '5', '6', '7', '8', '9']
if all([counts[x] == 1 for x in section_ids]) and valid_card_text:
good_text = True
else:
return UJSONResponse(
{
'text_format':
"<div class='gen-box warning'>Unfortunately, the AI created an invalid card. Please try again!</div>",
'image': ""
},
headers=response_header)
try:
r = requests.post(IMAGE_API_URL, json={'text': trunc_text}, timeout=10)
return UJSONResponse(r.json(), headers=response_header)
except:
return UJSONResponse({'text_format': trunc_text},
headers=response_header)
if __name__ == '__main__':
uvicorn.run(app, host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))
x),
)
@curry
def if_(if_func, func, arg):
"""Whether to apply a function or not
"""
if if_func(arg):
return func(arg)
return arg
@app.get("/get/")
async def get_binary_file(url: UrlStr):
"""Base endpoint to get binary file
"""
return sequence(
if_(search(r"https://drive\.google\.com(.*)"), modify_google),
requests.get,
lambda x: (BytesIO(x.content), x.headers["content-type"]),
lambda x: StreamingResponse(x[0], media_type=x[1]),
)(url)
if __name__ == "__main__":
# run with python main.py to debug
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)
]
arr = list(filter(("-").__ne__, arr))
print(arr)
reco = mal_scrap.big_list_recommendation(arr)
arr_reco = []
arr_reco2 = []
for i in reco:
print(reco[i][0])
if (i in arr):
arr_reco2.append(
[i, reco[i][0], reco[i][1] * reco[i][2], "background:#34495e"])
arr_reco.append(
[i, reco[i][0], reco[i][1], reco[i][2], "background:#34495e"])
else:
arr_reco2.append([i, reco[i][0], reco[i][1] * reco[i][2], ""])
arr_reco.append([i, reco[i][0], reco[i][1], reco[i][2], ""])
arr_reco = sorted(arr_reco, key=lambda l: l[2], reverse=True)
arr_reco2 = sorted(arr_reco2, key=lambda l: l[2], reverse=True)
return templates.TemplateResponse("download.html", {
"request": request,
"data": arr_reco,
"data2": arr_reco2
})
if __name__ == "__main__":
uvicorn.run(app, host="127.0.0.1", port=5001)
body = await request.json()
address = body.get('address')
db.createTransaction(address)
@app.get('/api/create-transaction')
async def createTransaction():
db.createTransaction()
@app.post('/api/get-address-transactions')
async def getAddressTransactions(request: Request):
body = await request.json()
address = body.get('address')
transactions = db.getAddressTransactions(address)
return jsonable_encoder(transactions)
@app.get('/api/get-transactions')
def getTransactions():
transactions = db.getTransactions()
return jsonable_encoder(transactions)
if __name__ == '__main__':
uvicorn.run('app:app',
host='0.0.0.0',
port=8000,
log_level='info',
reload=True)
example_query = """
{
allEmployees(sort: [NAME_ASC, ID_ASC]) {
edges {
node {
id
name
department {
id
name
}
role {
id
name
}
}
}
}
}
"""
app = FastAPI()
app.add_route("/", GraphQLApp(schema=schema, graphiql=True))
if __name__ == "__main__":
from database import init_db
import uvicorn
init_db()
uvicorn.run(app, port=5000, debug=True)
await redis_plugin.init()
await database.connect()
# for big files can try https://stackoverflow.com/a/48229517
with open('tarif.json', 'r') as file:
data = ujson.load(file)
# TODO optimize it for big json
for key, value in data.items():
for cargo in value:
await redis_plugin.redis.hmset_dict(
key,
{
# the cargo_type is key, the rate is value:
cargo["cargo_type"]:
cargo["rate"]
})
@app.on_event('shutdown')
async def on_shutdown() -> None:
await redis_plugin.terminate()
await database.disconnect()
DEBUG = os.getenv("DEBUG") == 'True'
if __name__ == "__main__" and DEBUG:
import uvicorn
uvicorn.run("main:app", debug=True, reload=True)
cron_day_of_week=job.cron_day_of_week,
cron_month=job.cron_month,
run_type=1,
enabled=0,
is_lock=1,
priority=999,
create_time=now,
)
await database.execute(query=query, values=values)
return {'result': 'succ'}
@app.post('/delete_db_job/')
async def delete_db_job(job: UpdateJob):
update_sql = f"delete from scheduler where id={job.id}"
await database.execute(update_sql)
return {'result': 'succ'}
@app.post("/upload/")
async def upload_file(file: UploadFile = File(...)):
try:
return {"filename": file.filename, 'result': 'fail', 'msg': "请使用 main_rpc_server.py 才可以使用上传！"}
except Exception as e:
raise HTTPException(status_code=400, detail="file upload fail")
if __name__ == '__main__':
u.run(app, host="0.0.0.0", port=8081)
from fastapi import FastAPI
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
import settings
import os
from starlette.graphql import GraphQLApp
from starlette.datastructures import Secret
from graphql_repo.mutation import Mutation
from graphql_repo.schema import Query
import graphene
import uvicorn
app = FastAPI()
app.add_route(
"/", GraphQLApp(schema=graphene.Schema(query=Query, mutation=Mutation)))
if __name__ == "__main__":
uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)
@app.get('/blog/unpublished')
def unpublished():
return {'data' : 'all unplublished blog'}
@app.get('/blog/{id}')
def show(id: int):
return {'data': id}
@app.get('/blog/{id}/comment')
def comments(id: int, limit=10):
return {'data' : f'{id} and {limit}'}
class Blog(BaseModel):
title: str
body: str
published: Optional[bool]
@app.post('/blog')
def create_blog(request: Blog):
return {'data': f'blog is created with {request.title}'}
if __name__ == '__main__':
uvicorn.run(app, host='0.0.0.0', port=5000)
def bind_entrypoint(self, ep: Entrypoint):
ep.bind_dependency_overrides_provider(self)
self.routes.extend(ep.routes)
self.on_event('shutdown')(ep.shutdown)
if __name__ == '__main__':
import uvicorn
app = API()
api_v1 = Entrypoint('/api/v1/jsonrpc')
class MyError(BaseError):
CODE = 5000
MESSAGE = "My error"
class DataModel(BaseModel):
details: str
@api_v1.method(errors=[MyError])
def echo(data: str = Body(..., example='123'), ) -> str:
if data == 'error':
raise MyError(data={'details': 'error'})
else:
return data
app.bind_entrypoint(api_v1)
uvicorn.run(app, port=5000, debug=True, access_log=False)
else:
raise
loop = asyncio.get_event_loop()
tasks = [asyncio.ensure_future(setup_learner())]
learn = loop.run_until_complete(asyncio.gather(*tasks))[0]
loop.close()
@app.route('/')
async def homepage(request):
html_file = path / 'view' / 'index.html'
return HTMLResponse(html_file.open().read())
@app.route('/analyze', methods=['POST'])
async def analyze(request):
img_data = await request.form()
img_bytes = await (img_data['file'].read())
img = open_image(BytesIO(img_bytes))
prediction = classes[int(learn.predict(img)[1])]
return JSONResponse({'result': str(prediction)})
if __name__ == '__main__':
if 'serve' in sys.argv:
uvicorn.run(app=app,
host='0.0.0.0',
port=int(os.environ.get('PORT', 5000)),
log_level="info")
memory_usage_in_bytes = -1
cpu_usage_in_nanoseconds = -1
memory_usage_file_path = '/sys/fs/cgroup/memory/memory.usage_in_bytes'
if os.path.exists(memory_usage_file_path):
with open(memory_usage_file_path, 'r') as memory_fd:
memory_usage_in_bytes = int(memory_fd.read().strip())
cpu_usage_file_path = '/sys/fs/cgroup/cpu/cpuacct.usage'
if os.path.exists(cpu_usage_file_path):
with open(cpu_usage_file_path, 'r') as cpu_fd:
cpu_usage_in_nanoseconds = int(cpu_fd.read().strip())
data["pod"] = {
"memory_usage_in_bytes": memory_usage_in_bytes,
"cpu_usage_in_nanoseconds": cpu_usage_in_nanoseconds
}
return data
if __name__ == "__main__":
logging_setup()
logging.info(logf("Started metrics exporter process at port 8050"))
uvicorn.run("exporter:metrics_app",
host="0.0.0.0",
port=8050,
log_level="info")
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import uvicorn
from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
from starlette.requests import Request
from starlette.responses import PlainTextResponse
from qllr import app
from qllr.settings import HOST, PORT, TRUSTED_PROXIES
class TrustedProxiesMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next: RequestResponseEndpoint):
if "x-forwarded-for" in request.headers:
if request.client.host not in TRUSTED_PROXIES:
return PlainTextResponse("Client address spoofing detected", 403)
return await call_next(request)
app.add_middleware(ProxyHeadersMiddleware)
app.add_middleware(TrustedProxiesMiddleware)
if __name__ == "__main__":
uvicorn.run(app, host=HOST, port=PORT, lifespan="on")
async def do_login(request):
form = await request.form()
username = form.get('username')
password = form.get('password')
LOG.info(f'Attempting login for {username}')
response = await session.login(request, username, password, api)
return response
@app.route('/network/action/{form_name}')
async def network_action_form_get(request):
form_name = request.path_params['form_name']
query = api.get_form_query(form_name, **request.query_params)
results = await api.call(
query,
request=request
)
resp = {
'errors': cannula.format_errors(results.errors),
'data': results.data or {}
}
return JSONResponse(resp)
if __name__ == '__main__':
if USE_MOCKS:
api.middleware.insert(0, MockMiddleware(mock_all=False))
uvicorn.run(app, host='0.0.0.0', port=int(PORT), debug=True, log_level=logging.INFO)
# ################
# Exception Handler
# ################
@APP.exception_handler(pydantic.error_wrappers.ValidationError)
async def handle_validation_error(
request: Request, exc: pydantic.error_wrappers.ValidationError): # pylint: disable=unused-argument
"""
Handles validation errors.
"""
return JSONResponse({"message": exc.errors()}, status_code=422)
# ################
# Routing
# ################
# Include routers.
APP.include_router(V1, prefix="", tags=["v1"])
APP.include_router(V2, prefix="/v2", tags=["v2"])
# Running of app.
if __name__ == "__main__":
uvicorn.run(
"app.main:APP",
host="127.0.0.1",
port=int(os.getenv("PORT", "5000")),
log_level="info",
)
from fastapi import FastAPI
import uvicorn
separator = ', '
app = FastAPI()
class Endpoint:
def get(self, path, queries, return_function_name):
queries = separator.join(queries)
exec(f"""@app.get("{path}")
async def end({queries}): return {return_function_name}({queries})""")
end = Endpoint()
def plus(a, b):
return a + b
end.get(path="/hi", queries=['a', 'b'], return_function_name="plus")
if __name__ == "__main__":
uvicorn.run(app, host="localhost", port=8000)
def start(self):
"""Start tile server."""
uvicorn.run(app=self.app,
host=self.host,
port=self.port,
log_level="info")
local.interfaces = local.get_if_info()
return {'interfaces': local.interfaces}
# removing due to fastapi issue #894, outlets method was not being used for anything currently so disabling for now
# @app.get('/api/v1.0/outlets')
# def get_outlets(request: Request, outlets=OUTLETS):
# log_request(request, 'outlets')
# # -- Collect Outlet Details remove sensitive data --
# if outlets:
# outlets = cpi.pwr.pwr_get_outlets()
# cpiexec.wait_for_threads()
# if outlets and 'defined' in outlets:
# outlets['defined'] = {p: {k: v for k, v in outlets['defined'][p].items()
# if k not in ['username', 'password']} for p in outlets['defined']}
# return outlets
@app.get('/api/v1.0/details')
def get_details(request: Request):
log_request(request, 'details')
global last_update
if int(time()) - last_update > 20:
local.data = local.build_local_dict(refresh=True)
last_update = int(time())
return local.data
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=5000, log_level="info")
def main():
uvicorn.run(app, host="0.0.0.0", port=9000)
origins = ["http://*****:*****@app.get("/")
async def read_root():
return {"Hello": "World"}
@app.get("/new_example")
async def create_example():
return {}
@app.post("/new_dsm/")
from typing import Optional
import uvicorn
from fastapi import FastAPI
from odmantic import AIOEngine, Field, Model
app = FastAPI()
engine = AIOEngine(database="fastapi-app")
class Publisher(Model):
name: str
founded: int = Field(ge=1440)
location: Optional[str] = None
@app.get("/")
async def root():
publisher = Publisher(name="Garfield", founded=100000)
await engine.save(publisher)
return publisher
if __name__ == "__main__":
from debugger import initialize_server_debugger_if_needed
initialize_server_debugger_if_needed()
uvicorn.run("main:app", host="0.0.0.0", port=8000, debug=True)
detail=f'File "{file_path}" not found.')
body = await request.body()
post_req = [
req for req in post_entries[file_path] if req.request_data == body
]
if not post_req:
print('data not found:', body)
raise HTTPException(status_code=404,
detail='No response exists for given content')
post_req = post_req[0]
return Response(post_req.response_data,
headers={
'mimeType': post_req.mime_type,
'Content-Type': post_req.mime_type
})
if __name__ == '__main__':
config_kwargs = dict(
app=app,
host='0.0.0.0',
port=int(os.getenv('PORT', 80)),
# workers=1,
log_level='info',
)
uvicorn.run(**config_kwargs)
def calculate(a: int = None, b: int = None):
c = a + b
res = {"res": c}
return res
@app.get('/')
def hello():
return "Hello1"
class Item(BaseModel):
POS: str = None
@app.post('/test')
def calculate(request_data: Item):
if request_data.POS:
doc = nlp(request_data.POS)
result = {}
for token in doc:
result[token.text] = token.pos_
return result
return "error"
if __name__ == '__main__':
import uvicorn
uvicorn.run(app=app, host='0.0.0.0', port=8080, workers=1)
message = "\n\nThis model was trained with an old version of fastai and will not work in a CPU environment.\n\nPlease update the fastai library in your training environment and export your model again.\n\nSee instructions for 'Returning to work' at https://course.fast.ai."
raise RuntimeError(message)
else:
raise
loop = asyncio.get_event_loop()
tasks = [asyncio.ensure_future(setup_learner())]
learn = loop.run_until_complete(asyncio.gather(*tasks))[0]
loop.close()
@app.route('/')
async def homepage(request):
html_file = path / 'view' / 'index.html'
return HTMLResponse(html_file.open().read())
@app.route('/analyze', methods=['POST'])
async def analyze(request):
img_data = await request.form()
img_bytes = await (img_data['file'].read())
img = open_image(BytesIO(img_bytes))
prediction = learn.predict(img)[0]
return JSONResponse({'result': str(prediction)})
if __name__ == '__main__':
if 'serve' in sys.argv:
uvicorn.run(app=app, host='0.0.0.0', port=5000, log_level="info")
import logging
import os
import uvicorn
from main import app
LOG = logging.getLogger(__name__)
HOST = os.getenv('HOST', '0.0.0.0')
PORT = int(os.getenv('PORT', '80'))
if __name__ == '__main__':
env_string = F"HOST={HOST}\nPORT={PORT}\n"
logging.basicConfig(
level=logging.INFO,
format=
'%(asctime)s.%(msecs)03d|%(name)-12s|%(levelname)-8s| %(message)s',
datefmt='%m-%d %H:%M:%S')
LOG.info(F"Environmnet Vars:\n{env_string}")
uvicorn.run(app, host=HOST, port=PORT)
model_fit = model.fit(disp=0)
fc, se, conf = model_fit.forecast(1)
diff = fc - last_day
return fc, diff
def overall(ticker):
df, last_day = data(ticker)
order = best_order(df)
fc, diff = model(df, order, last_day)
return last_day, fc, diff
app = FastAPI()
@app.get('/')
def index():
return {'message': 'Hello!'}
@app.post('/predict')
async def predict_price(ticker: str):
last_day, fc, diff = overall(ticker)
return {'prediction': fc[0], 'difference:': diff[0]}
if __name__ == '__main__':
uvicorn.run(app, host='127.0.0.1', port=8000)
def start():
if os.path.exists("./.temp") is False:
os.mkdir("./.temp")
if os.path.exists("./.serve") is False:
os.mkdir("./.serve")
uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)
import uvicorn
import engineio
eio = engineio.AsyncServer(async_mode='asgi')
app = engineio.ASGIApp(eio, static_files={
'/': {'content_type': 'text/html', 'filename': 'simple.html'},
'/static/engine.io.js': {'content_type': 'application/javascript',
'filename': 'static/engine.io.js'}
})
@eio.on('connect')
def connect(sid, environ):
print("connect ", sid)
@eio.on('message')
async def message(sid, data):
print('message from', sid, data)
await eio.send(sid, 'Thank you for your message!', binary=False)
@eio.on('disconnect')
def disconnect(sid):
print('disconnect ', sid)
if __name__ == '__main__':
uvicorn.run(app, host='127.0.0.1', port=5000)
To use these interactive docs:
- Click on an endpoint below
- Click the **Try it out** button
- Edit the Request body or any parameters
- Click the **Execute** button
- Scroll down to see the Server response Code & Details
"""
app = FastAPI(
title='DS API',
description=description,
docs_url='/',
)
app.include_router(db.router, tags=['Database'])
app.include_router(ml.router, tags=['Machine Learning'])
app.include_router(external.router, tags=['External Resources'])
app.include_router(viz.router, tags=['Visualizations'])
app.add_middleware(
CORSMiddleware,
allow_origins=['*'],
allow_credentials=True,
allow_methods=['*'],
allow_headers=['*'],
)
if __name__ == '__main__':
uvicorn.run(app)
app = FastAPI()
origins = [
"http://localhost",
"http://*****:*****@app.get("/")
async def main():
return {"message": "Hello World"}
app.include_router(label_sys.router)
app.include_router(task.router)
app.include_router(document.router)
app.include_router(users.router)
if __name__ == "__main__":
uvicorn.run(app='main:app', host="0.0.0.0", port=9000, reload=True, debug=False)
raise GraphQLError("Invalid credentials")
user = crud.get_user_by_username(db, username=token_data.username)
if user is None:
raise GraphQLError("Invalid credentials")
AnimeSearch = route_optima_search(query, title, str(title))
return SearchAnime(AnimeSearch=AnimeSearch)
class MyMutations(graphene.ObjectType):
user = CreateUser.Field()
authen_user = AuthenUser.Field()
get_anime_list = GetAnimeList.Field()
search_anime = SearchAnime.Field()
app = FastAPI()
origins = ["http://localhost", "http://localhost:4200"]
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.add_route(
"/graphql",
GraphQLApp(schema=graphene.Schema(query=Query, mutation=MyMutations)))
if __name__ == "__main__":
uvicorn.run(app, host="127.0.0.1", port=8000)
async def setup_learner():
await download_file(model_file_url, path/'models'/f'{model_file_name}.pth')
data_bunch = ImageDataBunch.single_from_classes(path, classes,
tfms=get_transforms(), size=224).normalize(imagenet_stats)
learn = create_cnn(data_bunch, models.resnet34, pretrained=False)
learn.load(model_file_name)
return learn
loop = asyncio.get_event_loop()
tasks = [asyncio.ensure_future(setup_learner())]
learn = loop.run_until_complete(asyncio.gather(*tasks))[0]
loop.close()
@app.route('/')
def index(request):
html = path/'view'/'index.html'
return HTMLResponse(html.open().read())
@app.route('/analyze', methods=['POST'])
async def analyze(request):
data = await request.form()
img_bytes = await (data['file'].read())
img = open_image(BytesIO(img_bytes))
prediction = learn.predict(img)[0]
return JSONResponse({'result': str(prediction)})
if __name__ == '__main__':
if 'serve' in sys.argv: uvicorn.run(app, host='0.0.0.0', port=5042)
from flask import Flask, render_template, request
import requests as rq
import argparse as argp
import uvicorn
parser = argp.ArgumentParser()
parser.add_argument('-n', '--host', type=str, default='0.0.0.0')
parser.add_argument('-p', '--port', type=int, default=5000)
parser.add_argument('-l', '--log-level', type=str, default='info')
args = parser.parse_args()
app = Flask(__name__)
@app.route('/', methods=['GET', 'POST'])
def index():
data = {'encode': 'UTC-8'}
if request.method == 'POST':
url = request.form['url']
res = rq.get(url)
res.encoding = res.apparent_encoding
data['html'] = res.text
data['encode'] = request.form['encode']
print(url)
return render_template('index.html', **data)
if __name__ == '__main__':
uvicorn.run(app, host=args.host, port=args.port, log_level=args.log_level, interface='wsgi', lifespan='off')
