def main():
if len(sys.argv) < 1:
print("Usage: fdk <func_module> [entrypoint]")
sys.exit("at least func module must be specified")
if not os.path.exists(sys.argv[1]):
sys.exit("Module: {0} doesn't exist".format(sys.argv[1]))
if len(sys.argv) > 2:
handler = customer_code.Function(sys.argv[1], entrypoint=sys.argv[2])
else:
handler = customer_code.Function(sys.argv[1])
fdk.handle(handler)
"AUTH_PROVIDER_X509_CERT_URL", os.environ.get("auth_provider_x509_cert_url"))
g_client_x509_cert_url = os.environ.get(
"CLIENT_X509_CERT_URL", os.environ.get("client_x509_cert_url"))
if not all([g_type, g_project_id, g_private_key_id, g_private_key,
g_client_email, g_auth_uri, g_token_uri,
g_auth_provider_x509_cert_url, g_client_x509_cert_url]):
raise Exception("One or more GCloud auth attributes empty.")
g_private_key = g_private_key.replace("\\n", "\n")
gcloup_map = {
"type": g_type,
"project_id": g_project_id,
"private_key_id": g_private_key_id,
"private_key": g_private_key,
"client_email": g_client_email,
"client_id": g_client_id,
"auth_uri": g_auth_uri,
"token_uri": g_token_uri,
"auth_provider_x509_cert_url": g_auth_provider_x509_cert_url,
"client_x509_cert_url": g_client_x509_cert_url,
}
credentials = service_account.Credentials.from_service_account_info(
gcloup_map, scopes=['https://www.googleapis.com/auth/cloud-platform', ])
return vision.ImageAnnotatorClient(
credentials=credentials,
scopes=['https://www.googleapis.com/auth/cloud-platform', ])
if __name__ == "__main__":
fdk.handle(inject_client(setup_client()))
def compute_functions(function, args):
"""These are all of the additional functions for the compute service"""
if function == "submit_job":
from compute.submit_job import run as _submit_job
return _submit_job(args)
elif function == "get_job":
from compute.get_job import run as _get_job
return _get_job(args)
elif function == "get_pending_job_uids":
from compute.get_pending_job_uids import run as _get_job_uids
return _get_job_uids(args)
elif function == "set_cluster":
from compute.set_cluster import run as _set_cluster
return _set_cluster(args)
else:
from admin.handler import MissingFunctionError
raise MissingFunctionError()
if __name__ == "__main__":
import fdk
from admin.handler import create_async_handler
fdk.handle(create_async_handler(compute_functions))
def access_functions(function, args):
""" This function routes the passed arguments to the function
selected by the function parameter.
"""
if function == "request":
from access.request import run as _request
return _request(args)
elif function == "run_calculation":
from access.run_calculation import run as _run_calculation
return _run_calculation(args)
else:
from admin.handler import MissingFunctionError
raise MissingFunctionError()
if __name__ == "__main__":
import fdk
from admin.handler import create_async_handler
fdk.handle(create_async_handler(access_functions))
logger.info("Launching function")
token = None
try:
body = json.loads(data.getvalue())
token = body.get("token")
except (Exception, ValueError) as ex:
logger.error(f"error; {str(ex)}")
if token != auth_token:
return response.Response(
ctx, response_data=json.dumps(
{"message": "Error"}),
headers={"Content-Type": "application/json"}
)
learning_sites = load_learning_sites()
async with aiohttp.ClientSession() as client:
await asyncio.gather(*(fetch(client, site) for site in learning_sites))
return response.Response(
ctx, response_data=json.dumps(
{"message": "Success"}),
headers={"Content-Type": "application/json"}
)
if __name__ == "__main__":
loop = asyncio.get_event_loop()
fdk.handle(handler, loop=loop)
from hugs_service.cleardatasources import clear_datasources
return clear_datasources(args)
if function == "status":
from hugs_service.status import status
return status()
if function == "job_runner":
from hugs_service.jobrunner import job_runner
return job_runner(args)
if function == "rank_sources":
from hugs_service.rank_sources import rank_sources
return rank_sources(args)
if function == "get_sources":
from hugs_service.get_sources import get_sources
return get_sources(args)
else:
from admin.handler import MissingFunctionError
raise MissingFunctionError()
if __name__ == "__main__":
import fdk
from admin.handler import create_async_handler
fdk.handle(create_async_handler(hugs_functions))
'port={port}'
.format(host=pg_host,
database=pg_db,
user=pg_user,
passwd=pg_pswd,
port=pg_port)
)
final = {}
print("establishing connection\n", file=sys.stderr, flush=True)
conn = psycopg2.connect(pg_dns)
print("connection acquired\n", file=sys.stderr, flush=True)
cur = conn.cursor()
print("cursor created\n", file=sys.stderr, flush=True)
cur.execute(CREATE)
for o in [MAIN_SELECT, ALT_SELECT]:
cur.execute(o["q"])
result = collections.defaultdict(int)
rows = cur.fetchall()
for row in rows:
emotion, count = row
result[emotion] = count
full_result = dict(result)
final[o["name"]] = full_result
print("stats created\n", file=sys.stderr, flush=True)
return json.dumps(final)
if __name__ == "__main__":
fdk.handle(select_votes)
import fdk
@fdk.coerce_http_input_to_content_type
def app(context, data=None, loop=None):
"""
User's request body handler
:param context: request context
:type context: hotfn.http.request.RequestContext
:param data: request body, it's type depends on request Content-Type header
:type data: object
:param loop: asyncio event loop
:type loop asyncio.AbstractEventLoop
:return: echo of data
:rtype: object
"""
return data
if __name__ == "__main__":
fdk.handle(app)
input key in the object store. This function is designed
to be called asynchronously by Fn, as it will only
return when the gromacs simulation is complete."""
if data and len(data) > 0:
try:
from json import loads
data = loads(data)
bucket = account.connect_to_bucket( data["login"],
data["compartment"],
data["bucket"] )
# Must clear anything that already exists
objstore.clear_all_except( bucket, ["input.tar.bz2"] )
(status, message) = gromacs_runner.run(bucket)
message = "<output>%s</output>" % message
except Exception as e:
status = -2
message = "<error>%s</error>" % str(e)
else:
status = -1
message = "<error>No input data, so no simulation to run!</error>"
return {"status" : status, "message" : message }
if __name__ == "__main__":
from fdk import handle
handle(handler)
def registry_functions(function, args):
"""This function routes calls to sub-functions, thereby allowing
a single registry function to stay hot for longer
"""
if function == "get_service":
from registry.get_service import run as _get_service
return _get_service(args)
elif function == "register_service":
from registry.register_service import run as _register_service
return _register_service(args)
else:
from admin.handler import MissingFunctionError
raise MissingFunctionError()
if __name__ == "__main__":
import fdk
from admin.handler import create_async_handler
fdk.handle(create_async_handler(registry_functions))
content, status, headers = await call
assert 200 == status
def handle(ctx, data=None, **kwargs):
payload = None
if data and len(data) > 0:
payload = ujson.loads(data)
records = payload.get("Records", [])
for record in records:
s3 = record.get("s3", {})
obj, bucket = s3.get("object", {}), s3.get("bucket", {})
bucket_name = bucket.get("name")
image_key = obj.get("key")
if all((bucket_name, image_key)):
url = "{0}/{1}/{2}".format(os.environ.get("MINIO_SERVER_URL"),
bucket_name, image_key)
message = {'url': url, 'id': image_key}
message_json = ujson.dumps(message)
(pn.publish().channel(bucket_name).message(
[message_json]).use_post(True).sync())
if __name__ == "__main__":
fdk.handle(handle)
elif function == "list_drives":
from storage.list_drives import run as _list_drives
return _list_drives(args)
elif function == "list_versions":
from storage.list_versions import run as _list_versions
return _list_versions(args)
elif function == "open_drive":
from storage.open_drive import run as _open_drive
return _open_drive(args)
elif function == "open_uploader":
from storage.open_uploader import run as _open_uploader
return _open_uploader(args)
elif function == "resolve_par":
from storage.resolve_par import run as _resolve_par
return _resolve_par(args)
elif function == "upload":
from storage.upload import run as _upload
return _upload(args)
elif function == "upload_chunk":
from storage.upload_chunk import run as _upload_chunk
return _upload_chunk(args)
else:
from admin.handler import MissingFunctionError
raise MissingFunctionError()
if __name__ == "__main__":
import fdk
from admin.handler import create_async_handler
fdk.handle(create_async_handler(storage_functions))
function: If valid function selected, function with args passed
else None
"""
if function == "cash_cheque":
from accounting.cash_cheque import run as _cash_cheque
return _cash_cheque(args)
elif function == "create_account":
from accounting.create_account import run as _create_account
return _create_account(args)
elif function == "deposit":
from accounting.deposit import run as _deposit
return _deposit(args)
elif function == "get_account_uids":
from accounting.get_account_uids import run as _get_account_uids
return _get_account_uids(args)
elif function == "get_info":
from accounting.get_info import run as _get_info
return _get_info(args)
elif function == "perform":
from accounting.perform import run as _perform
return _perform(args)
else:
from admin.handler import MissingFunctionError
raise MissingFunctionError()
if __name__ == "__main__":
import fdk
from admin.handler import create_async_handler
fdk.handle(create_async_handler(accounting_functions))
def fn(ctx, data=None, loop=None):
log = get_logger(ctx)
log.info("tf graph imported")
if data is not None or len(data) != 0:
data = ujson.loads(data)
log.info("incoming data: {0}".format(ujson.dumps(data)))
media = data.get("media", [])
event_id = data.get("event_id")
event_type = data.get("event_type", "")
if event_type.startswith("Microsoft"):
event_type = "Azure"
event_id = event_id.replace("-", "")
ran_on = data.get("ran_on", "Fn Project on Oracle Cloud")
for media_url in media:
img, status = process_single_media_file(
ctx, sess, media_url, label_map, event_id, event_type,
ran_on)
post_image(ctx, status, media_url, add_fn_logo(img))
else:
log.info("missing data")
return fn
if __name__ == "__main__":
load_tf_graph()
fdk.handle(with_graph(load_label_map()))
Returns:
function: If valid function selected, function with args passed
else None
"""
if function == "get_session_info":
from admin.get_session_info import run as _get_session_info
return _get_session_info(args)
elif function == "login":
from admin.login import run as _login
return _login(args)
elif function == "logout":
from admin.logout import run as _logout
return _logout(args)
elif function == "register":
from admin.register import run as _register
return _register(args)
elif function == "request_login":
from admin.request_login import run as _request_login
return _request_login(args)
else:
from admin.handler import MissingFunctionError
raise MissingFunctionError()
if __name__ == "__main__":
import fdk
from admin.handler import create_async_handler
fdk.handle(create_async_handler(identity_functions))
# Initialisation of the Random Forest algorithm with the estimator parameters
if estimator_params is not None:
rf = RandomForestClassifier(**estimator_params)
else:
rf = RandomForestClassifier()
# Fitting the model to the input training data
rf.fit(train_X, train_y)
logger.info('Finished fitting the model!')
# Persisting the model into function's local storage
joblib.dump(rf, '/tmp/model/model.pkl')
logger.info('Persisted the model locally!')
# Uploading the model into remote storage
minio_put_object(minio_client, model_object_bucket_name,
model_object_name, '/tmp/model/model.pkl', logger)
logger.info(
'Uploaded the model file to bucket: {0} with object name: {1}!'.
format(model_object_bucket_name, model_object_name))
# TODO - Return codes
return {"message": "Completed successfully!!!"}
else:
return {"message": "Data not sent!"}
if __name__ == "__main__":
fdk.handle(handler)
alt_emotions = data['alt']
main, alt = [], []
total = sum(list(main_emotions.values()))
for emotion, count in main_emotions.items():
main.append(
dict(emotion=emotion,
stat=float("{:.2f}".format(float(count / total) * 100)),
times=count))
for emotion, count in alt_emotions.items():
alt.append(
dict(emotion=emotion,
stat=float("{:.2f}".format(float(count / total) * 100)),
times=count))
print("final stats assembled\n", file=sys.stderr, flush=True)
render_context = {
"main_emotions": main,
"alt_emotions": alt,
"total": total
}
headers = {
"Content-Type": "text/html",
}
return response.RawResponse(context,
status_code=200,
headers=headers,
response_data=template.render(render_context))
if __name__ == "__main__":
fdk.handle(build_view)
