async def delete(self, request):
try:
note = await Note.objects.get(id=request.path_params.get("id"))
await note.delete()
return UJSONResponse({"success": True})
except NoMatch:
return UJSONResponse({"error": "not found"}, status_code=404)
async def homepage(request):
global generate_count
global sess
if request.method == 'GET':
params = request.query_params
elif request.method == 'POST':
params = await request.json()
elif request.method == 'HEAD':
return UJSONResponse({'text': ''},
headers=response_header)
gpt2.load_gpt2(sess, run_name=params.get('run_name', ''))
text = gpt2.generate(sess,
run_name=params.get('run_name', ''),
length=int(params.get('length', 1023)),
temperature=float(params.get('temperature', 0.7)),
top_k=int(params.get('top_k', 0)),
top_p=float(params.get('top_p', 0)),
prefix=params.get('prefix', '')[:500],
truncate=params.get('truncate', None),
include_prefix=str(params.get('include_prefix', True)).lower() == 'true',
return_as_list=True)[0]
sess = gpt2.reset_session(sess)
gc.collect()
return UJSONResponse({'text': text},
headers=response_header)
async def api_create_build(request: Request):
env_var_dict = await request.json()
try:
create_build(env_var_dict)
return UJSONResponse({"success": "true"})
except Exception as e:
return UJSONResponse({"success": "false", "error": str(e)})
async def homepage(request):
# global generate_count
# global sess
if request.method == 'GET':
params = request.query_params
elif request.method == 'POST':
params = await request.json()
elif request.method == 'HEAD':
return UJSONResponse({'text': ''},
headers=response_header)
text = interact_model(
input_text=params.get('input_text', 'The quick brown fox'),
model_name='124M',
seed=None,
nsamples=1,
batch_size=1,
length=None,
temperature=float(params.get('temperature', 1.0)),
top_k=int(params.get('top_k', 0)),
top_p=float(params.get('top_p', 1)),
models_dir='models',
)
gc.collect()
return UJSONResponse({'text': text},
headers=response_header)
async def api_create_checkpoint(request: Request):
try:
build = request.path_params["build"]
target = request.path_params["target"]
start_or_finish = request.path_params["start_or_finish"]
if start_or_finish not in ["start", "finish"]:
return UJSONResponse(
{
"success":
"false",
"error":
"api must be called with /api/checkpoint/start or /api/checkpoint/finish",
},
status_code=400,
)
report_checkpoint(
build,
time(),
start_or_finish,
target,
request.query_params.get("exit_code", None),
)
return UJSONResponse({"success": "true"})
except Exception as e:
return UJSONResponse({
"success": "false",
"error": str(e)
},
status_code=500)
async def homepage(request):
global generate_count
global sess
if request.method == 'GET':
params = request.query_params
elif request.method == 'POST':
params = await request.json()
elif request.method == 'HEAD':
return UJSONResponse({'text': ''}, headers=response_header)
text = gpt2.generate(sess,
length=int(params.get('length', 1023)),
temperature=float(params.get('temperature', 0.7)),
top_k=int(params.get('top_k', 0)),
top_p=float(params.get('top_p', 0)),
prefix=params.get('prefix', '')[:500],
truncate=params.get('truncate', None),
include_prefix=str(params.get(
'include_prefix', True)).lower() == 'true',
return_as_list=True)[0]
generate_count += 1
if generate_count == 8:
# Reload model to prevent Graph/Session from going OOM
tf.reset_default_graph()
sess.close()
sess = gpt2.start_tf_sess(threads=1)
gpt2.load_gpt2(sess)
generate_count = 0
gc.collect()
return UJSONResponse({'text': text}, headers=response_header)
def run_parse(self, name):
if not name:
UJSONResponse(make_response(error="no name param found"),
status_code=400)
self.logger.debug(f"name={name}")
names, category = process.get_names(name)
error = ""
if not names:
error = ""
elif category is None:
category = "Crowded"
error = "This name appears to represent many people."
elif category == process.CORP:
error = (
"The name appears to be from a corporation or other non-person entity."
)
return UJSONResponse(
make_response(
source=name,
names=names,
category=category,
error=error,
best=process.choose_name(names),
))
async def start(request):
k1 = request.path_params['k1']
query = invites.select().where(invites.c.invite_code == k1)
res = await database.fetch_one(query)
if res:
# even though it could be skipped, we want to ensure the invite code
# is valid before revealing any information
if res['is_used'] == False:
return UJSONResponse({
'callback': request.url_for("connect"),
'k1': k1,
'uri': config('NODE_URI'),
'tag': 'channelRequest'
})
else:
return UJSONResponse({
'status': 'ERROR',
'reason': 'this invite code has been used'
})
else:
return UJSONResponse({
'status': 'ERROR',
'reason': 'this invite code is invalid'
})
async def delete_place(place_id: int, request: Request):
status_code, payload, headers = await send_delete_people_by_place(place_id, request)
if status_code == status.HTTP_204_NO_CONTENT:
return UJSONResponse(status_code=status.HTTP_200_OK)
else:
return UJSONResponse(payload or {}, status_code=status_code, headers=headers)
async def countries_detail(request):
country_code = request.path_params["country_code"].upper()
country = app.countries.get(country_code)
if country:
return UJSONResponse(country)
else:
return UJSONResponse({"message": "Country code not found."})
async def geolocate_ip(request):
r = app.geoip2.country(request.path_params["ip"])
country = app.countries.get(r.country.iso_code)
if country:
return UJSONResponse(country)
else:
return UJSONResponse({"message": "Could not geocode request."})
async def geolocate(request):
country_code = request.headers.get("CF-IPCountry", "").upper()
country = app.countries.get(country_code)
if country:
return UJSONResponse(country)
else:
return UJSONResponse({"message": "Could not geocode request."})
async def homepage(request):
if request.method == 'GET':
params = request.query_params
elif request.method == 'POST':
params = await request.json()
elif request.method == 'HEAD':
return UJSONResponse({'text': ''}, headers=response_header)
# Validate request token
if REQUEST_TOKEN and params.get('token') != REQUEST_TOKEN:
return UJSONResponse({'text': 'Incorrect request token.'},
headers=response_header)
while True:
# You can adapt this block for any text-generation method.
text = gpt2.generate(sess,
length=300,
temperature=uniform(0.7, 1.0),
top_k=40,
return_as_list=True)[0]
if (len(text) > 0 and len(text) <= 280
and '<|startoftext|>' not in text):
break
api.update_status(text)
return UJSONResponse({'text': 'Tweet successful!'},
headers=response_header)
async def homepage(request):
if request.method == 'GET':
params = request.query_params
elif request.method == 'POST':
params = await request.json()
elif request.method == 'HEAD':
return UJSONResponse({'text': ''}, headers=response_header)
# Validate request token
if REQUEST_TOKEN and params.get('token') != REQUEST_TOKEN:
return UJSONResponse({'text': 'Incorrect request token.'},
headers=response_header)
db = create_engine(engine.url.URL(
drivername='postgres+pg8000',
username=DB_USER,
password=DB_PASS,
database=DB_NAME,
query={
'unix_sock': '/cloudsql/{}/.s.PGSQL.5432'.format(CONNECTION_NAME)
}),
pool_size=1)
metadata = MetaData()
tweets = Table('tweets', metadata, autoload=True, autoload_with=db)
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api = tweepy.API(auth)
with db.connect() as conn:
q = (select([tweets]).where(tweets.columns.account == ACCOUNT).where(
tweets.columns.tweet_timestamp == None).order_by(
func.random()).limit(1))
tweet = conn.execute(q).fetchone()
if tweet is None:
return UJSONResponse({'text': f"No more tweets left!"},
headers=response_header)
t = api.update_status(tweet.tweet)
# Save record of tweet to prevent reuse
t_timestamp = time.strftime("%Y-%m-%d %H:%M:%S+00", time.gmtime())
t_url = f"https://twitter.com/{t.user.screen_name}/status/{t.id_str}"
q_update = (tweets.update().where(
tweets.columns.id == tweet.id).values(tweet_timestamp=t_timestamp,
tweet_url=t_url))
conn.execute(q_update)
db.dispose()
return UJSONResponse({'text': f"Tweet posted! {t_url}"},
headers=response_header)
async def login(request):
user = await request.state.get_user()
credentials = await request.json()
if not await user.authenticate(**credentials):
return UJSONResponse({"message": "Bad username or password"}, 400)
if not user["is_active"]:
return UJSONResponse({"message": "User isn't active"}, 400)
user.login()
return UJSONResponse({})
async def change_password(request):
data = await request.json()
user = await request.state.get_user()
if not user:
return UJSONResponse({"message": "Log in first"}, 400)
user.set_password(data["password"])
await user.save(["password"])
user.logout()
return UJSONResponse({})
async def post(self, request):
data = await request.json()
async with get_conn() as conn:
try:
data = await Users(conn).change_password(
request.user, data['password'])
except ApiException as e:
return UJSONResponse({'error': str(e)}, status_code=400)
return UJSONResponse({})
async def api_get_checkpoint(request: Request):
build = request.path_params["build"]
target = request.path_params["target"]
if build == "*" and target == "*":
return UJSONResponse(
{
"success": "false",
"error": "must specify at least one of build or target",
},
status_code=400,
)
return UJSONResponse(get_checkpoint_by_build_and_target(build, target))
async def post_me(req):
"""Test POST route
"""
try:
# convert the body to json
data = await req.json()
return UJSONResponse({'msg': f'Hello {data["name"]}!'})
except JSONDecodeError:
return UJSONResponse({'msg': 'You posted nothing!!'})
except KeyError:
return UJSONResponse({'err': 'Please provide your name'},
status_code=400)
async def connect(request):
lnd_rpc = lnd_grpc.Client(
network=config('LND_NETWORK', default='mainnet'),
grpc_host=config('LND_GRPC_HOST', default='localhost'),
grpc_port=config('LND_GRPC_PORT', default='10009'))
try:
req = ChannelOpenRequest(**request.query_params)
try:
query = invites.select().where(invites.c.invite_code == req.k1)
res = await database.fetch_one(query)
if res:
if res['is_used'] == False:
next(lnd_rpc.open_channel(
node_pubkey=req.remoteid,
private=1 if config('LND_FORCE_PRIVATE', cast=bool, default=False) else req.private, # noqa
local_funding_amount=res['funding_amount'],
push_sat=res['push_amount'],
spend_unconfirmed=config('LND_SPEND_UNCONFIRMED', cast=bool, default=True), # noqa
sat_per_byte=config('LND_FEE_RATE', cast=int, default=None))) # noqa
q = invites.update().where(invites.c.invite_code == req.k1) \
.values(
is_used=True,
node_id=req.remoteid.hex(),
used_at=datetime.utcnow())
await database.execute(q)
return UJSONResponse({'status': 'OK'})
else:
return UJSONResponse({
'status': 'ERROR',
'reason': 'this invite code has been used'
})
else:
return UJSONResponse({
'status': 'ERROR',
'reason': 'this invite code is invalid'
})
except _MultiThreadedRendezvous as e:
return UJSONResponse({
'status': 'ERROR',
'reason': e.details()
})
except ValidationError as e:
return UJSONResponse({
'status': 'ERROR',
'reason': 'invalid parameter(s) provided'
})
async def status(request):
"""
Checks status of task and return result
when ready
"""
task_id = request.path_params.get("task_id")
result = tasks.get(task_id)
if result is not None and result["status"] is "Pending":
return UJSONResponse(result)
tasks.pop(task_id, None)
return UJSONResponse(result)
async def health_check():
status = True
response = dict()
db_status, _ = db_healthcheck()
broker_status, _ = broker_healthcheck()
status = status and db_status and broker_status
response["status"] = status
if status:
return UJSONResponse(response, status_code=200)
else:
response['errors'] = dict()
# Add errors here
return UJSONResponse(response, status_code=503)
async def homepage(request):
global generate_count
global sess
if request.method == 'GET':
params = request.query_params
elif request.method == 'POST':
params = await request.json()
elif request.method == 'HEAD':
return UJSONResponse({'text': ''}, headers=response_header)
# Validate request token
if REQUEST_TOKEN and params.get('token') != REQUEST_TOKEN:
return UJSONResponse({'text': 'Incorrect request token.'},
headers=response_header)
def generate_text():
generated_text = gpt2.generate(
sess,
length=int(params.get('length', 280)),
temperature=float(params.get('temperature', 0.9)),
top_p=float(params.get('top_p', 0.7)),
truncate=params.get('truncate', '<|endoftext|>'),
prefix=params.get('prompt', '<|startoftext|>')[:100],
include_prefix=str(params.get('include_prefix',
False)).lower() == 'true',
return_as_list=True,
nsamples=int(params.get('count', 1)),
batch_size=int(params.get('count', 1)))[0]
return generated_text
text = generate_text()
text = text.replace('<|startoftext|>', '')
text = text.replace('<|endoftext|>', '')
# Retry once if returned text is empty (may happen as millzbot isn't that good with prompts)
text = generate_text() if len(text) <= 2 else text
text = "I literally actually couldn't come up with something to say" if len(
text) == 0 else text
generate_count += 1
if generate_count == 9:
# Reload model to prevent Graph/Session from going OOM
tf.reset_default_graph()
sess.close()
sess = gpt2.start_tf_sess(threads=1)
gpt2.load_gpt2(sess)
generate_count = 0
gc.collect()
return UJSONResponse({'text': text}, headers=response_header)
async def aggregation(request) -> UJSONResponse:
"""
responses:
200:
description: A hello world response
examples:
{ status: "ok", result: { hello: "world" }}
"""
result = ''
status = 'error'
query = request.path_params['query']
query = '' if query in ['\"\"', '\'\''] else query
print('`%s`' % query)
aggregation_name = request.path_params['aggregation_name']
if not aggregation_name in ['top_tags', 'tweet_count', 'top_twitters']:
return UJSONResponse({
'aggregation': aggregation_name,
'result': result,
'status': status
})
if aggregation_name == 'top_tags':
with MongoConnection('twitter',
os.environ.get('MONGO_HOST', 'localhost'),
int(os.environ.get('MONGO_PORT', 27017))):
result = str(
get_top_hashtags(query=query,
limit=int(
request.query_params.get('limit', 10))))
status = 'ok'
if aggregation_name == 'tweet_count':
with MongoConnection('twitter',
os.environ.get('MONGO_HOST', 'localhost'),
int(os.environ.get('MONGO_PORT', 27017))):
result = str(get_tweet_count(query=query))
status = 'ok'
if aggregation_name == 'top_twitters':
with MongoConnection('twitter',
os.environ.get('MONGO_HOST', 'localhost'),
int(os.environ.get('MONGO_PORT', 27017))):
result = str(
get_top_twitters(query=query,
limit=int(
request.query_params.get('limit', 10))))
status = 'ok'
return UJSONResponse({
'aggregation': aggregation_name,
'result': result,
'status': status
})
async def verify_magic(data: models.Magic = Body(...)):
user = await security.authenticate_user_magic(data.email, data.secret)
if not user:
raise HTTPException(status_code=HTTP_400_BAD_REQUEST,
detail="Invalid Link")
access_token_expires = datetime.timedelta(
minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
access_token = security.create_access_token(
data={"sub": user.email}, expires_delta=access_token_expires)
response = UJSONResponse({"status": "authenticated"})
response.set_cookie(oauth2_scheme.token_name,
access_token,
httponly=True,
secure=secure_cookies)
return response
async def create_user(req):
"""Creates a new user
"""
try:
data = await req.json() # get request body as json (dict)
# construct UPDATE query and execute asynchronously
query = User.insert().values(name=data['name'])
await db.execute(query)
return UJSONResponse(
{'msg': f"Created new user with name {data['name']}"})
except (JSONDecodeError, KeyError):
# handle client error
return UJSONResponse({'err': 'Please supply a name'}, status_code=400)
async def complete_horses(request):
"""
Auto-completes the horse names as the user enters a name.
This route isn't accessed directly by the user, but is
used by JavaScript to auto-complete for horses.
:param request: The HTTP request
"""
# Get the query
q: str = request.query_params.get("q", None)
if q is None:
# User didn't give a query
return UJSONResponse({"error": "You didn't specify a query."},
status_code=400)
# Get the limit of horses
try:
limit: int = int(request.query_params.get("limit", 10))
except ValueError:
# Default limit of 10 horses
limit = 10
# Clamp the limit (minimum 1 horse, maximum 100 horse)
limit = max(1, min(100, limit))
# Make the query
query = (select([horses.c.name, horses.c.age]).where(
horses.c.name.ilike(q + "%")).order_by(horses.c.name).limit(limit))
# Fetch it all
result = []
async for row in database.iterate(query):
# Fetch the first word of the horse name and age
name_prefix = row[0].split(" ", 1)[0]
age = DIGITS.match(row[1])
# If the horse has an invalid age value in the database, skip it
if age is None:
print("WARNING, skipping", row[0], "because of invalid age")
continue
result.append(
["{},{}".format(name_prefix, age.group(0)), row[0],
age.group(0)])
# Return a response
return UJSONResponse(result)
async def get_multi_runs_events(request):
event_kind = request.path_params["event_kind"]
force = to_bool(request.query_params.get("force"), handle_none=True)
if event_kind not in V1ArtifactKind.allowable_values:
raise HTTPException(
detail="received an unrecognisable event {}.".format(event_kind),
status_code=status.HTTP_400_BAD_REQUEST,
)
run_uuids = request.query_params["runs"]
event_names = request.query_params["names"]
orient = request.query_params.get("orient")
orient = orient or V1Events.ORIENT_DICT
event_names = {e
for e in event_names.split(",")
if e} if event_names else set([])
run_uuids = {e
for e in run_uuids.split(",") if e} if run_uuids else set([])
events = await get_archived_operations_events(
run_uuids=run_uuids,
event_kind=event_kind,
event_names=event_names,
orient=orient,
check_cache=not force,
)
return UJSONResponse({"data": events})
async def answers_user(request):
id = request.path_params["id"]
results = await User.get(username=id)
result = await Answer.all().filter(ans_user_id=results.id)
# Serialize the queryset
answers = answers_schema.dump(result)
return UJSONResponse({"answers": answers})
async def single_database_query(request):
row_id = randint(1, 10000)
async with connection_pool.acquire() as connection:
number = await connection.fetchval(READ_ROW_SQL, row_id)
return UJSONResponse({'id': row_id, 'randomNumber': number})
