aimodelshare 0.3.7__py3-none-any.whl

aimodelshare/data_sharing/share_data.py

@@ -0,0 +1,373 @@
+#import docker
+import os
+import shutil
+import importlib.resources as pkg_resources
+#import importlib_resources as pkg_resources
+from . import data_sharing_templates
+from string import Template
+import zipfile
+import time
+import json
+import boto3
+import tempfile
+import requests
+import uuid
+
+delay=3
+
+def create_bucket(s3_client, bucket_name, region):
+        try:
+            response=s3_client.head_bucket(Bucket=bucket_name)
+        except:
+            if(region=="us-east-1"):
+                response = s3_client.create_bucket(
+                    ACL="private",
+                    Bucket=bucket_name
+                )
+            else:
+                location={'LocationConstraint': region}
+                response=s3_client.create_bucket(
+                    ACL="private",
+                    Bucket=bucket_name,
+                    CreateBucketConfiguration=location
+                )
+        return response
+
+
+
+def create_iam_role(iam_client, role_name, trust_relationship):
+    response = iam_client.create_role(RoleName=role_name, AssumeRolePolicyDocument=json.dumps(trust_relationship))
+    time.sleep(delay)
+
+def create_iam_policy(iam_client, account_id, policy_name, policy):
+    policy_arn = "arn:aws:iam::" + account_id + ":policy/" + policy_name
+    response = iam_client.create_policy(PolicyName=policy_name, PolicyDocument=json.dumps(policy))
+    time.sleep(delay)
+
+def attach_policy_to_role(iam_client, account_id, role_name, policy_name):
+    policy_arn = "arn:aws:iam::" + account_id + ":policy/" + policy_name
+    response = iam_client.attach_role_policy(RoleName = role_name, PolicyArn = policy_arn)
+    time.sleep(delay)
+
+def create_docker_folder_local(dataset_dir, dataset_name, python_version):
+
+    tmp_dataset_dir = tempfile.gettempdir() + '/' + '/'.join(['tmp_dataset_dir', dataset_name])
+
+    tmp_dataset = tempfile.gettempdir() + '/' + 'tmp_dataset_dir'
+
+    os.mkdir(tmp_dataset)
+
+    shutil.copytree(dataset_dir, tmp_dataset_dir)
+
+    #data = pkg_resources.read_text(data_sharing_templates, 'Dockerfile.txt')
+    with open(os.path.join('data_sharing_templates', 'Dockerfile.txt'), 'r') as file:
+        data = file.read()
+
+    template = Template(data)
+    newdata = template.substitute(
+        python_version=python_version)
+    with open(os.path.join(tmp_dataset, 'Dockerfile'), 'w') as file:
+        file.write(newdata)
+
+def create_docker_folder_codebuild(dataset_dir, dataset_name, template_folder, region, registry_uri, repository, dataset_tag, python_version):
+
+    tmp_dataset_dir = tempfile.gettempdir() + '/' + '/'.join(['tmp_dataset_dir', dataset_name])
+
+    tmp_dataset = tempfile.gettempdir() + '/' + 'tmp_dataset_dir'
+    tmp_dataset = tmp_dataset.replace("/tmp//tmp/","/tmp/")
+
+
+    if os.path.exists(tmp_dataset):
+        shutil.rmtree(tmp_dataset)    
+    os.makedirs(tmp_dataset)
+
+    if dataset_dir:
+        shutil.copytree(dataset_dir, tmp_dataset_dir)
+
+    template_folder= template_folder.replace("/tmp//tmp/","/tmp/")
+    os.mkdir(template_folder)
+
+    data = pkg_resources.read_text(data_sharing_templates, 'Dockerfile.txt')
+    #with open(os.path.join('data_sharing_templates', 'Dockerfile.txt'), 'r') as file:
+    #    data = file.read()
+
+    template = Template(data)
+    newdata = template.substitute(
+        python_version=python_version)
+    with open(os.path.join(template_folder, 'Dockerfile'), 'w') as file:
+        file.write(newdata)
+    
+    data = pkg_resources.read_text(data_sharing_templates, 'buildspec.txt')
+    #with open(os.path.join('data_sharing_templates', 'buildspec.txt'), 'r') as file:
+    #    data = file.read()
+
+    template = Template(data)
+    newdata = template.substitute(
+        aws_access_key_id=os.environ['AWS_ACCESS_KEY_ID_AIMS'],
+        aws_secret_access_key=os.environ['AWS_SECRET_ACCESS_KEY_AIMS'],
+        region='region',
+        registry_uri=registry_uri,
+        repository=repository,
+        dataset_tag=dataset_tag)
+    with open(os.path.join(template_folder, 'buildspec.yml'), 'w') as file:
+        file.write(newdata)
+
+    response = shutil.copytree(tmp_dataset, '/'.join([template_folder, 'tmp_dataset_dir']))
+
+    def get_all_file_paths(directory):
+        file_paths = []
+        for root, directories, files in os.walk(directory):
+            for filename in files:
+                filepath = os.path.join(root, filename)
+                file_paths.append(filepath)
+        return file_paths
+
+    file_paths = get_all_file_paths(template_folder)
+
+    template_folder_len = len(template_folder)
+
+    with zipfile.ZipFile(''.join([template_folder, '.zip']),'w') as zip:
+        for file in file_paths:
+            try:
+                zip.write(file, file[template_folder_len:])
+            except:
+                pass
+
+    shutil.rmtree(tmp_dataset)
+    
+    shutil.rmtree(template_folder)
+
+#def share_data_local(dataset_dir, tag='latest', python_version='3.8'):
+
+    #create_docker_folder_local(dataset_dir)
+
+    #client = docker.from_env()
+
+    #client.images.build(path='./tmp_dataset_folder', tag=tag)
+
+    #shutil.rmtree('tmp_dataset_dir')
+
+    # send to ecr
+    
+    # client.images.
+
+    # client.push(repository,
+
+    # ecr_client.create_repository
+
+    # docker tag aimodelshare-base-image:latest 517169013426.dkr.ecr.us-east-1.amazonaws.com/aimodelshare-base-image:latest
+    # aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
+    # docker push public.ecr.aws/y2e2a1d6/aimodelshare-image-classification-public
+
+def share_data_codebuild(account_id, region, dataset_dir, dataset_tag='latest', python_version='3.8'):
+
+    print('Uploading your data. Please wait for a confirmation message.')
+    
+    region = 'us-east-1'
+
+    session = boto3.session.Session(aws_access_key_id=os.environ.get("AWS_ACCESS_KEY_ID_AIMS"),
+                                    aws_secret_access_key = os.environ.get("AWS_SECRET_ACCESS_KEY_AIMS"), 
+                                    region_name=region)
+
+    flag = 0
+
+    if dataset_dir:
+        dataset_name = dataset_dir.replace(" ", "_")
+    else:
+        dataset_name = "placeholder_data"
+    dataset_name=dataset_name.replace("/tmp/","")
+    repository=dataset_name+'-repository'
+
+    template_folder=tempfile.gettempdir() + '/' + dataset_name+'_'+dataset_tag
+    template_folder= template_folder.replace("/tmp//tmp/","/tmp/")
+    codebuild_role_name=dataset_name+'-codebuild-role'
+
+    codebuild_policies_name=dataset_name+'-codebuild-policies'
+
+    codebuild_dataset_name=dataset_name+'-upload'
+    
+
+    s3_client = session.client('s3', region_name=region)
+
+    bucket_name = "aimodelshare"+str(account_id)+"sharedata"
+    
+    create_bucket(s3_client, bucket_name, region)
+    
+    s3_resource = session.resource('s3', region_name=region)
+
+    bucket_versioning = s3_resource.BucketVersioning(bucket_name)
+    response = bucket_versioning.enable()
+
+    # ecr = session.client('ecr')
+
+    ecr = session.client('ecr-public')
+
+    registry_uri = ecr.describe_registries()['registries'][0]['registryUri']
+
+    try:
+        response = ecr.create_repository(
+            repositoryName=repository
+        )
+    except:
+        pass
+
+    create_docker_folder_codebuild(dataset_dir, dataset_name, template_folder, region, registry_uri, repository, dataset_tag, python_version)
+
+    iam = session.client('iam')
+
+    codebuild_trust_relationship = json.loads(pkg_resources.read_text(data_sharing_templates, 'codebuild_trust_relationship.txt'))
+    try:
+        create_iam_role(iam, codebuild_role_name, codebuild_trust_relationship)
+    except:
+        None
+
+    codebuild_policies = json.loads(pkg_resources.read_text(data_sharing_templates, 'codebuild_policies.txt'))
+    try:
+        create_iam_policy(iam, account_id, codebuild_policies_name, codebuild_policies)
+    except:
+        None
+
+    try:
+        attach_policy_to_role(iam, account_id, codebuild_role_name, codebuild_policies_name)
+    except:
+        None
+             
+    s3_client = session.client('s3')
+    s3_client.upload_file(''.join([template_folder, '.zip']),
+                          bucket_name,
+                          ''.join([dataset_name+'_'+dataset_tag, '.zip']))
+
+    codebuild = session.client('codebuild')
+    
+    try:
+        response = codebuild.create_project(
+            name=codebuild_dataset_name,
+            source={
+                'type': 'S3',
+                'location': bucket_name + '/' + dataset_name+'_'+dataset_tag + '.zip'
+            },
+            artifacts={
+                'type': 'NO_ARTIFACTS',
+            },
+            environment={
+                'type': 'LINUX_CONTAINER',
+                'image': 'aws/codebuild/standard:5.0',
+                'computeType': 'BUILD_GENERAL1_SMALL',
+                'privilegedMode': True
+            },
+            serviceRole=codebuild_role_name
+        )
+    except:
+        response = codebuild.delete_project(
+            name=codebuild_dataset_name
+        )
+        response = codebuild.create_project(
+            name=codebuild_dataset_name,
+            source={
+                'type': 'S3',
+                'location': bucket_name + '/' + dataset_name+'_'+dataset_tag + '.zip'
+            },
+            artifacts={
+                'type': 'NO_ARTIFACTS',
+            },
+            environment={
+                'type': 'LINUX_CONTAINER',
+                'image': 'aws/codebuild/standard:5.0',
+                'computeType': 'BUILD_GENERAL1_SMALL',
+                'privilegedMode': True
+            },
+            serviceRole=codebuild_role_name
+        )
+
+    response = codebuild.start_build(
+        projectName=codebuild_dataset_name
+    )
+
+    os.remove(template_folder+'.zip')
+
+    return {"ecr_uri": registry_uri + '/' + repository + ':' + dataset_tag}
+
+def share_dataset(data_directory="folder_file_path",classification="default", private="FALSE"):
+    data_directory=str(data_directory).lower()
+    aishare_datasetname = input("Enter dataset name:")
+    aishare_datadescription = input(
+        "Enter data description (i.e.- filenames denoting training and test data, file types, and any subfolders where files are stored):")
+    aishare_datatags = input(
+        "Enter tags to help users find your data (i.e.- flower dataset, image, supervised learning, classification")   
+    datalicense=input("Insert license (Optional): ")
+    datacitation=input("Insert citation (Optional): ")
+    modelplaygroundurl=input("Insert AI Model Share model playground url (Optional): ")
+    problemdomain=input("Enter a number signifying your dataset problem domain or data type: 1 = Image 2 = Video 3 = Text 4 = Tabular 5 = Neural Style Transfer 6 = Object Detection 7 = Other \n")
+
+    optiondict={"1":"Image", "2":"Video","3":"Text","4":"Tabular", "5": "Audio","6":"Neural Style Transfer", "7": "Object Detection", "8":"Other"}
+    problemdomainfinal=optiondict.get(problemdomain,"Other")
+
+
+    user_session = boto3.session.Session(aws_access_key_id=os.environ.get("AWS_ACCESS_KEY_ID_AIMS"),
+                                          aws_secret_access_key = os.environ.get("AWS_SECRET_ACCESS_KEY_AIMS"), 
+                                         region_name=os.environ.get("AWS_REGION_AIMS"))
+    account_number = user_session.client(
+        'sts').get_caller_identity().get('Account')
+
+    datauri=share_data_codebuild(account_number,os.environ.get("AWS_REGION"),data_directory)
+
+
+    #TODO: Replace redis data code with new api post call, see helper code below from competition api
+    #TODO: add "dataset:id" as models are ingested on the backend
+    bodydata = {"dataowner": os.environ.get("username"),  # change this to first and last name
+                "dataname":aishare_datasetname ,                
+                'datadescription':aishare_datadescription,
+                'datatags':aishare_datatags,
+                'dataecruri':datauri['ecr_uri'],
+                'datalicense':datalicense,
+                'datacitation':datacitation,
+                'classification':classification,
+                "modelplaygroundurl": modelplaygroundurl,
+                "Private": private,
+                "delete": "FALSE",
+                "problemdomain":problemdomainfinal}
+
+    # datasets api
+    headers_with_authentication = {'Content-Type': 'application/json', 'authorizationToken': os.environ.get("JWT_AUTHORIZATION_TOKEN"), 'Access-Control-Allow-Headers':
+                                   'Content-Type,X-Amz-Date,authorizationToken,Access-Control-Allow-Origin,X-Api-Key,X-Amz-Security-Token,Authorization', 'Access-Control-Allow-Origin': '*'}
+    # modeltoapi lambda function invoked through below url to return new prediction api in response
+    response=requests.post("https://jyz9nn0joe.execute-api.us-east-1.amazonaws.com/dev/modeldata",
+                  json=bodydata, headers=headers_with_authentication)
+    return "Your dataset has been shared to modelshare.org."
+
+def delete_dataset(ecr_uri):
+
+    session = boto3.session.Session(aws_access_key_id=os.environ.get("AWS_ACCESS_KEY_ID_AIMS"),
+                                    aws_secret_access_key = os.environ.get("AWS_SECRET_ACCESS_KEY_AIMS"), 
+                                    region_name=os.environ.get("AWS_REGION_AIMS"))
+
+    ecr_client = session.client('ecr-public')
+
+    repository_image = ecr_uri.split('/')[2]
+
+    repository = repository_image.split(':')[0]
+    image = repository_image.split(':')[1]
+
+    response = ecr_client.batch_delete_image(
+        repositoryName=repository,
+        imageIds=[
+            {
+                'imageTag': image
+            }
+        ]
+    )
+
+    image_details = ecr_client.describe_images(
+        repositoryName=repository
+    )
+
+    print("The dataset accessible at '" + ecr_uri + "' has been deleted successfully.")
+
+    if len(image_details['imageDetails'])==0:
+        response = ecr_client.delete_repository(
+            repositoryName=repository
+        )
+
+    print("The registry '" + repository + " has been deleted successfully.")
+
+    return

aimodelshare/data_sharing/utils.py

@@ -0,0 +1,8 @@
+import stat # needed for file stat
+import os
+
+# arguments: the function that failed, the path 
+# it failed on, and the error that occurred.
+def redo_with_write(redo_func, path, err):
+    os.chmod(path, stat.S_IWRITE)
+    redo_func(path)

aimodelshare/deploy_custom_lambda.py

@@ -0,0 +1,246 @@
+import boto3
+import os
+import requests
+import uuid
+import json
+import math
+import time
+import datetime
+import onnx
+import tempfile
+import shutil
+import sys
+import pickle
+import tempfile
+
+from aimodelshare.tools import extract_varnames_fromtrainingdata, _get_extension_from_filepath
+from aimodelshare.aws import get_s3_iam_client, run_function_on_lambda, get_token, get_aws_token, get_aws_client
+from aimodelshare.bucketpolicy import _custom_upload_policy
+from aimodelshare.exceptions import AuthorizationError, AWSAccessError, AWSUploadError
+from aimodelshare.api import create_prediction_api
+from aimodelshare.api import get_api_json
+
+from aimodelshare.preprocessormodules import upload_preprocessor
+from aimodelshare.model import _get_predictionmodel_key, _extract_model_metadata
+
+# what is private here
+# what if deployment_dir is not present? Not handled yet
+# Return section and private parameter documentation left
+# output_list_exampledata list being accessed by which key in response?
+# create file_objects in temp_dir, abstract from user
+# convert example output from list to json, in frontend display value of key of result
+
+def create_bucket(s3_client, bucket_name, region):
+        try:
+            response=s3_client.head_bucket(Bucket=bucket_name)
+        except:
+            if(region=="us-east-1"):
+                response = s3_client.create_bucket(
+                    ACL="private",
+                    Bucket=bucket_name
+                )
+            else:
+                location={'LocationConstraint': region}
+                response=s3_client.create_bucket(
+                    ACL="private",
+                    Bucket=bucket_name,
+                    CreateBucketConfiguration=location
+                )
+        return response
+
+
+def deploy_custom_lambda(input_json_exampledata, output_json_exampledata, lambda_filepath, deployment_dir, private, custom_libraries):
+
+    """
+        Deploys an AWS Lambda function based on the predict() function specified in the lambda_filepath .py file
+        Inputs : 6
+        Output : Information about the deployed API
+
+        -----------
+
+        Parameters :
+
+        input_json_exampledata : JSON object [REQUIRED]
+                                 JSON object representing the structure of input that Lambda expects to receive
+
+        output_json_exampledata : List of element(s) [REQUIRED]
+                                  List of element(s) representing the output that the Lambda will return
+        
+        lambda_filepath : String [REQUIRED]
+                          Expects relative/absolute path to the .py file containing the predict() function,
+                          imports to all other custom libraries that are defined by the user and used by the
+                          predict() function can be placed in the deployment_dir directory
+        
+        deployment_dir : String
+                         Expects relative/absolute path to the directory containing all the files being used by the
+                         predict() function in the lambda_filepath .py file
+
+        private : string
+
+        custom_libraries : String of libraries ("library_1,library_2")
+                           Expects a list of strings denoting libraries required for Lambda to work
+                           Strings must be libraries present in PyPi
+                           Installation will follow pattern - pip install <library_name>
+
+        -----------
+
+        Returns
+
+        api_info : prints statements with generated live prediction API details
+                   also prints steps to update the model submissions by the user/team
+    """
+
+    temp_dir = tempfile.gettempdir()
+
+    file_objects_folder_path = os.path.join(temp_dir, 'file_objects')
+
+    # if 'file_objects' is not the name of deployment directory deployment_dir, 'file_objects' directory
+    # is created and contents of the deployment_dir directory are copied to 'file_objects' directory
+    if deployment_dir != file_objects_folder_path:
+        if os.path.exists(file_objects_folder_path):
+            shutil.rmtree(file_objects_folder_path)
+        shutil.copytree(deployment_dir, file_objects_folder_path)
+
+    # if 'custom_lambda.py' is not the name of the custom lambda .py file lambda_filepath, 'custom_lambda.py' file
+    # is created and contents of lambda_filepath .py file is written into 'custom_lambda.py'
+    if lambda_filepath != 'custom_lambda.py':
+        with open(lambda_filepath, 'r') as in_f:
+            with open('custom_lambda.py', 'w') as out_f:
+                out_f.write(in_f.read())
+
+    # create json and upload to API folder in S3 for displaying
+    json_exampledata = {
+        "input_json_exampledata": input_json_exampledata,
+        "output_json_exampledata": output_json_exampledata
+    }
+
+    with open(os.path.join(temp_dir, 'exampledata.json'), 'w') as f:
+        json.dump(json_exampledata, f)
+
+    aws_access_key_id = str(os.environ.get("AWS_ACCESS_KEY_ID_AIMS"))
+    aws_secret_access_key = str(os.environ.get("AWS_SECRET_ACCESS_KEY_AIMS"))
+    region_name = str(os.environ.get("AWS_REGION_AIMS"))
+
+    ### COMMENTS - TO DO
+    api_json= get_api_json()        # why is this required
+    user_client = boto3.client(     # creating apigateway client
+        'apigateway',
+        aws_access_key_id=aws_access_key_id,
+        aws_secret_access_key=aws_secret_access_key,
+        region_name=region_name
+    )
+    response2 = user_client.import_rest_api(        # what is being imported
+        failOnWarnings = True,
+        parameters = {'endpointConfigurationTypes': 'REGIONAL'},
+        body = api_json
+    )
+    ###
+
+    start = datetime.datetime.now()
+
+    api_id = response2['id']
+    now = datetime.datetime.now()
+    s3, iam, region = get_s3_iam_client(aws_access_key_id, aws_secret_access_key, region_name)
+    create_bucket(s3['client'], os.environ.get("BUCKET_NAME"), region)
+
+    apiurl = create_prediction_api(None, str(api_id), 'custom', 'FALSE', [], api_id, "TRUE", custom_libraries)
+
+    print("\n\nWe need some information about your model before we can generate your API.\n")
+    aishare_modelname = input("Name your deployment: ")
+    aishare_modeldescription = input("Describe your deployment: ")
+    aishare_modelevaluation = input("Describe your deployment's performance (OPTIONAL): ")
+    aishare_tags = input("Enter comma-separated search categories for your deployment (OPTIONAL): ")
+    aishare_apicalls = 0
+    print('')
+    # unpack user credentials
+    unique_model_id = str(api_id)
+    bucket_name = os.environ.get("BUCKET_NAME")
+
+    # why is this being done here, can it not be abstracted
+
+    categorical="FALSE" # categorical is being used where, for what
+    bodydata = {
+        "id": int(math.log(1/((time.time()*1000000)))*100000000000000),
+        "unique_model_id": unique_model_id,
+        "apideveloper": os.environ.get("username"),  # change this to first and last name
+        "apimodeldescription": aishare_modeldescription,
+        "apimodelevaluation": aishare_modelevaluation,
+        "apimodeltype": 'custom',
+        # getting rid of extra quotes that screw up dynamodb string search on apiurls
+        "apiurl": apiurl['body'].strip('\"'),
+        "bucket_name": bucket_name,
+        "version": 1,
+        "modelname": aishare_modelname,
+        "tags": aishare_tags,
+        "Private": private,
+        "Categorical": categorical,
+        "delete": "FALSE",
+    }
+
+    # Get the response
+    headers_with_authentication = {'Content-Type': 'application/json', 'authorizationToken': os.environ.get("JWT_AUTHORIZATION_TOKEN"), 'Access-Control-Allow-Headers':
+                                   'Content-Type,X-Amz-Date,authorizationToken,Access-Control-Allow-Origin,X-Api-Key,X-Amz-Security-Token,Authorization', 'Access-Control-Allow-Origin': '*'}
+    
+    # modeltoapi lambda function invoked through below url to return new prediction api in response
+    requests.post("https://bhrdesksak.execute-api.us-east-1.amazonaws.com/dev/modeldata",
+                  json=bodydata, headers=headers_with_authentication)
+
+    # Get the response
+    headers_with_authentication = {'Content-Type': 'application/json', 'authorizationToken': os.environ.get("JWT_AUTHORIZATION_TOKEN"), 'Access-Control-Allow-Headers':
+                                   'Content-Type,X-Amz-Date,authorizationToken,Access-Control-Allow-Origin,X-Api-Key,X-Amz-Security-Token,Authorization', 'Access-Control-Allow-Origin': '*'}
+    # modeltoapi lambda function invoked through below url to return new prediction api in response
+    response = requests.post("https://bhrdesksak.execute-api.us-east-1.amazonaws.com/dev/modeldata",
+                              json=bodydata, headers=headers_with_authentication)
+    response_string = response.text
+    response_string = response_string[1:-1]
+
+    end = datetime.datetime.now()    # end timer
+    difference = (end - start).total_seconds()
+    finalresult2 = "Your AI Model Share API was created in " + \
+        str(int(difference)) + " seconds." + " API Url: " + apiurl['body']
+    s3, iam, region = get_s3_iam_client(os.environ.get("AWS_ACCESS_KEY_ID"), os.environ.get("AWS_SECRET_ACCESS_KEY"), os.environ.get("AWS_REGION"))
+    policy_response = iam["client"].get_policy(
+        PolicyArn=os.environ.get("POLICY_ARN")
+    )
+    user_policy = iam["resource"].UserPolicy(
+        os.environ.get("IAM_USERNAME"), policy_response['Policy']['PolicyName'])
+    response = iam["client"].detach_user_policy(
+        UserName= os.environ.get("IAM_USERNAME"),
+        PolicyArn=os.environ.get("POLICY_ARN")
+    )
+    # add new policy that only allows file upload to bucket
+    policy = iam["resource"].Policy(os.environ.get("POLICY_ARN"))
+    response = policy.delete()
+    s3upload_policy = _custom_upload_policy(bucket_name, unique_model_id)
+    s3uploadpolicy_name = 'temporaryaccessAImodelsharePolicy' + \
+        str(uuid.uuid1().hex)
+    s3uploadpolicy_response = iam["client"].create_policy(
+        PolicyName=s3uploadpolicy_name,
+        PolicyDocument=json.dumps(s3upload_policy)
+    )
+    user = iam["resource"].User(os.environ.get("IAM_USERNAME"))
+    response = user.attach_policy(
+        PolicyArn=s3uploadpolicy_response['Policy']['Arn']
+    )
+    finalresultteams3info = "Your team members can submit improved models to your prediction api using the update_model_version() function."
+    api_info = finalresult2+"\n"
+
+    # Build output {{{
+    final_message = ("Follow this link to explore your Model Playground's functionality\n"
+                     "You can make predictions with the cURL functionality and access example code from the Programmatic tab.\n")
+    web_dashboard_url = ("https://www.modelshare.org/detail/"+ response_string)
+
+    end = datetime.datetime.now()
+    difference = (end - start).total_seconds()
+    finalresult2 = "Success! Your Model Playground was created in " + \
+        str(int(difference)) + " seconds."
+
+    print(api_info)
+
+    print("\n\n" + final_message + web_dashboard_url)
+    
+    return
+
+__all__ = [
+    deploy_custom_lambda
+]

aimodelshare/documentation/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

aimodelshare/documentation/karma_sphinx_theme/__init__.py

@@ -0,0 +1,28 @@
+import os
+
+from karma_sphinx_theme import _version as version
+
+
+def get_path():
+    """
+    Shortcut for users whose theme is next to their conf.py.
+    """
+    # Theme directory is defined as our parent directory
+    return os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
+
+
+def update_context(app, pagename, templatename, context, doctree):
+    context['karma_sphinx_theme_version'] = version.__version__
+
+def setup(app):
+    """ add_html_theme is new in Sphinx 1.6+ """
+
+    if hasattr(app, 'add_html_theme'):
+        theme_path = os.path.abspath(os.path.dirname(__file__))
+        app.add_html_theme('karma_sphinx_theme', theme_path)
+    app.connect('html-page-context', update_context)
+
+    return {
+        'version': version.__version__,
+        'parallel_read_safe': True
+    }

aimodelshare/documentation/karma_sphinx_theme/_version.py

@@ -0,0 +1,2 @@
+__version_info__ = (0, 0, 8)
+__version__ = '.'.join(map(str, __version_info__))