Initial migration + added examples

Author: CI

README.md

@@ -1,12 +1,17 @@
-# Algorithm Development Kit (ADK), Python edition 
+# Algorithm Development Kit (ADK), Python edition
+
 ```python
-import Algorithmia
+import from adk import ADK
+
+
 # API calls will begin at the apply() method, with the request body passed as 'input'
 # For more details, see algorithmia.com/developers/algorithm-development/languages
 
 def apply(input):
     return "hello {}".format(str(input))
-algo = Algorithmia.handler(apply)
+
+
+algo = ADK(apply)
 algo.serve()
 ```
 
@@ -31,12 +36,12 @@ This kit, when implemented by an algorithm developer - enables an easy way to ge
 
 Algorithm development does change with this introduction:
 - Primary development file has been renamed to `src/Algorithm.py` to aide in understanding around what this file actually does / why it's important
-- An additional import (`from Algorithmia import Handler`)
+- An additional import (`from adk import ADK`)
 - An optional `load()` function that can be implemented
     - this enables a dedicated function for preparing your algorithm for runtime operations, such as model loading, configuration, etc
 - A call to the handler function with your `apply` and optional` load` functions as inputs
     - ```python
-      algo = Algorithmia.handler(apply)
+      algo = ADK(apply)
       algo.serve()
       ```
     - converts the project into an executable, rather than a library
@@ -45,4 +50,7 @@ Algorithm development does change with this introduction:
       - this includes being able to step through your algorithm code in your IDE of choice! Just execute your `src/Algorithm.py` script
 
 ## Example workflows
-TODO
+Check out these examples to help you get started:
+- [hello world example](examples/hello_world)
+- [hello world example with loaded state](examples/loaded_state_hello_world)
+- [pytorch based image classification](examples/pytorch_image_classification)

src/ADK.py renamed to adk/ADK.py

@@ -10,7 +10,7 @@
 
 class ADK(object):
 
-    def __init__(self, apply_func, load_func):
+    def __init__(self, apply_func, load_func=None):
         """
         Creates the adk object
         :param apply_func: A required function that can have an arity of 1-2, depending on if loading occurs
@@ -20,20 +20,26 @@ def __init__(self, apply_func, load_func):
         apply_args, _, _, apply_defaults, _, _, _ = inspect.getfullargspec(apply_func)
         # apply_args, _, _, apply_defaults = inspect.getargspec(apply_func)
         # j = inspect.getfullargspec(apply_func)
-        load_args, _, _, _, _, _, _ = inspect.getfullargspec(load_func)
-        if len(load_args) > 0:
-            raise Exception("load function must not have parameters")
+        if load_func:
+            load_args, _, _, _, _, _, _ = inspect.getfullargspec(load_func)
+            if len(load_args) > 0:
+                raise Exception("load function must not have parameters")
+            self.load_func = load_func
+        else:
+            self.load_func = None
         if len(apply_args) > 2 or len(apply_args) == 0:
             raise Exception("apply function may have between 1 and 2 parameters, not {}".format(len(apply_args)))
         self.apply_func = apply_func
-        self.load_func = load_func
         self.is_local = not os.path.exists(self.FIFO_PATH)
         self.load_result = None
 
     def load(self):
         self.load_result = self.load_func()
-        print('PIPE_INIT_COMPLETE')
-        sys.stdout.flush()
+        if self.is_local:
+            print("loading complete")
+        else:
+            print('PIPE_INIT_COMPLETE')
+            sys.stdout.flush()
 
     def format_data(self, request):
         if request['content_type'] in ['text', 'json']:
@@ -74,36 +80,45 @@ def format_response(self, response):
         })
         return response_string
 
-    def write_to_pipe(self, data_string):
+    def write_to_pipe(self, payload):
         if self.is_local:
-            return data_string
+            if isinstance(payload, dict):
+                raise Exception(payload)
+            else:
+                print(payload)
         else:
             if os.name == "posix":
                 with open(self.FIFO_PATH, 'w') as f:
-                    f.write(data_string)
+                    f.write(payload)
                     f.write('\n')
                 sys.stdout.flush()
             if os.name == "nt":
-                sys.stdin = data_string
+                sys.stdin = payload
+
+    def create_exception(self, exception):
+        if hasattr(exception, 'error_type'):
+            error_type = exception.error_type
+        else:
+            error_type = 'AlgorithmError'
+        response = {
+            'error': {
+                'message': str(exception),
+                'stacktrace': traceback.format_exc(),
+                'error_type': error_type
+            }
+        }
+        return response
 
     def serve(self):
         try:
-            self.load()
+            if self.load_func:
+                self.load()
         except Exception as e:
-            if hasattr(e, 'error_type'):
-                error_type = e.error_type
-            else:
-                error_type = 'AlgorithmError'
-            load_error_string = json.dumps({
-                'error': {
-                    'message': str(e),
-                    'stacktrace': traceback.format_exc(),
-                    'error_type': error_type
-                }
-            })
-            l = self.write_to_pipe(load_error_string)
-            return l
-        response_string = ""
+            load_error = self.create_exception(e)
+            self.write_to_pipe(load_error)
+        response_obj = ""
+        if self.is_local:
+            print("waiting for input...")
         for line in sys.stdin:
             try:
                 request = json.loads(line)
@@ -112,20 +127,8 @@ def serve(self):
                     apply_result = self.apply_func(formatted_input, self.load_result)
                 else:
                     apply_result = self.apply_func(formatted_input)
-                response_string = self.format_response(apply_result)
+                response_obj = self.format_response(apply_result)
             except Exception as e:
-                if hasattr(e, 'error_type'):
-                    error_type = e.error_type
-                else:
-                    error_type = 'AlgorithmError'
-                response_string = json.dumps({
-                    'error': {
-                        'message': str(e),
-                        'stacktrace': traceback.format_exc(),
-                        'error_type': error_type
-                    }
-                })
+                response_obj = self.create_exception(e)
             finally:
-                res = self.write_to_pipe(response_string)
-                if res:
-                    return res
+                self.write_to_pipe(response_obj)

adk/__init__.py

@@ -0,0 +1 @@
+from .ADK import ADK

examples/algorithm_basic.py

@@ -0,0 +1,2 @@
+algorithmia>=1.7,<2
+algorithmia-adk>=1.0,<2

examples/hello_world/requirements.txt

@@ -0,0 +1,9 @@
+from adk import ADK
+
+
+def apply(input):
+    return "hello {}".format(str(input))
+
+
+algorithm = ADK(apply)
+algorithm.serve()

examples/hello_world/src/Algorithm.py

@@ -0,0 +1,2 @@
+algorithmia>=1.7,<2
+algorithmia-adk>=1.0,<2

examples/hello_world/src/__init__.py

@@ -0,0 +1,28 @@
+from adk import ADK
+
+
+# API calls will begin at the apply() method, with the request body passed as 'input'
+# For more details, see algorithmia.com/developers/algorithm-development/languages
+
+def apply(input, state):
+    # If your apply function uses state that's loaded into memory via load, you can pass that loaded state to your apply
+    # function by defining an additional "state" parameter in your apply function.
+    return "hello {} {}".format(str(input), str(state))
+
+
+def load():
+    # Here you can optionally define a function that will be called when the algorithm is loaded.
+    # The return object from this function can be passed directly as input to your apply function.
+    # A great example would be any model files that need to be available to this algorithm
+    # during runtime.
+    # Any variables returned here, will be passed as the secondary argument to your 'algorithm' function
+
+    return "Loading has been completed."
+
+
+# This turns your library code into an algorithm that can run on the platform.
+# If you intend to use loading operations, remember to pass a `load` function as a second variable.
+algo = ADK(apply, load)
+# The 'serve()' function actually starts the algorithm, you can follow along in the source code
+# to see how everything works.
+algo.serve()

examples/loaded_state_hello_world/requirements.txt

@@ -0,0 +1,6 @@
+algorithmia>=1.7,<2
+algorithmia-adk
+six
+Pillow==8.1.0
+torch==1.6.0
+torchvision>=0.7

examples/loaded_state_hello_world/src/Algorithm.py

@@ -0,0 +1,94 @@
+import Algorithmia
+from adk import ADK
+import torch
+from PIL import Image
+import json
+from torchvision import models, transforms
+
+CLIENT = Algorithmia.client()
+SMID_ALGO = "algo://util/SmartImageDownloader/0.2.x"
+LABEL_PATH = "data://AlgorithmiaSE/image_cassification_demo/imagenet_class_index.json"
+MODEL_PATHS = {
+    "squeezenet": 'data://AlgorithmiaSE/image_cassification_demo/squeezenet1_1-f364aa15.pth',
+    'alexnet': 'data://AlgorithmiaSE/image_cassification_demo/alexnet-owt-4df8aa71.pth',
+}
+
+
+def load_labels():
+    local_path = CLIENT.file(LABEL_PATH).getFile().name
+    with open(local_path) as f:
+        labels = json.load(f)
+    labels = [labels[str(k)][1] for k in range(len(labels))]
+    return labels
+
+
+def load_model(name):
+    if name == "squeezenet":
+        model = models.squeezenet1_1()
+        models.densenet121()
+        weights = torch.load(CLIENT.file(MODEL_PATHS['squeezenet']).getFile().name)
+    else:
+        model = models.alexnet()
+        weights = torch.load(CLIENT.file(MODEL_PATHS['alexnet']).getFile().name)
+    model.load_state_dict(weights)
+    return model.float().eval()
+
+
+def get_image(image_url):
+    input = {"image": image_url, "resize": {'width': 224, 'height': 224}}
+    result = CLIENT.algo(SMID_ALGO).pipe(input).result["savePath"][0]
+    local_path = CLIENT.file(result).getFile().name
+    img_data = Image.open(local_path)
+    return img_data
+
+
+def infer_image(image_url, n, state):
+    model = state['model']
+    labels = state['labels']
+    image_data = get_image(image_url)
+    transformed = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                             std=[0.229, 0.224, 0.225])])
+    img_tensor = transformed(image_data).unsqueeze(dim=0)
+    infered = model.forward(img_tensor)
+    preds, indicies = torch.sort(torch.softmax(infered.squeeze(), dim=0), descending=True)
+    predicted_values = preds.detach().numpy()
+    indicies = indicies.detach().numpy()
+    result = []
+    for i in range(n):
+        label = labels[indicies[i]].lower().replace("_", " ")
+        confidence = float(predicted_values[i])
+        result.append({"label": label, "confidence": confidence})
+    return result
+
+
+def load():
+    output = {'model': load_model("squeezenet"), 'labels': load_labels()}
+    return output
+
+
+def apply(input, state):
+    if isinstance(input, dict):
+        if "n" in input:
+            n = input['n']
+        else:
+            n = 3
+        if "data" in input:
+            if isinstance(input['data'], str):
+                output = infer_image(input['data'], n, state)
+            elif isinstance(input['data'], list):
+                for row in input['data']:
+                    row['predictions'] = infer_image(row['image_url'], n, state)
+                output = input['data']
+            else:
+                raise Exception("'data' must be a image url or a list of image urls (with labels)")
+            return output
+        else:
+            raise Exception("'data' must be defined")
+    else:
+        raise Exception('input must be a json object')
+
+
+adk = ADK(apply_func=apply, load_func=load)
+adk.serve()

examples/loaded_state_hello_world/src/__init__.py

@@ -4,24 +4,16 @@
 
 setup(
     name='algorithmia-adk',
-    version='0.1.2',
-    description='Algorithmia python ADK client',
-    long_description='Algorithmia Python Client is a client library for accessing Algorithmia from python code. This library also gets bundled with any Python algorithms in Algorithmia.',
-    url='http://github.com/algorithmiaio/algorithmia-python',
+    version='0.1.0',
+    description='adk python ADK client',
+    long_description='adk Development Kit code used for creating Python algorithms on adk.',
+    url='http://github.com/algorithmiaio/algorithmia-adk-python',
     license='MIT',
-    author='Algorithmia',
+    author='adk',
     author_email='[email protected]',
-    packages=['Algorithmia'],
-    entry_points = {
-    'console_scripts': ['algo = Algorithmia.__main__:main']
-    },
+    packages=['adk'],
     install_requires=[
-        'requests',
         'six',
-        'enum34',
-        'toml',
-        'argparse',
-        'algorithmia-api-client>=1.3,<1.4'
     ],
     include_package_data=True,
     classifiers=[
@@ -31,11 +23,12 @@
         'License :: OSI Approved :: MIT License',
         'Operating System :: OS Independent',
         'Programming Language :: Python',
-        'Programming Language :: Python :: 2',
-        'Programming Language :: Python :: 2.6',
-        'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.3',
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
         'Topic :: Software Development :: Libraries :: Python Modules',
     ],
 )