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)