Merge pull request #1 from roboflow-ai/rerouting

full refactor of pip package

Author: Brad Dwyer

roboflow/.DS_Store

@@ -3,67 +3,74 @@
 import time
 
 import requests
-
+from roboflow.core.workspace import Workspace
 from roboflow.core.project import Project
 from roboflow.config import *
 
 
-def auth(api_key):
+def check_key(api_key):
     if type(api_key) is not str:
         raise RuntimeError(
             "API Key is of Incorrect Type \n Expected Type: " + str(type("")) + "\n Input Type: " + str(type(api_key)))
 
-    response = requests.post(API_URL + "/token", data=({
-        "api_key": api_key
-    }))
-
+    response = requests.post(API_URL + "/?api_key=" + api_key)
     r = response.json()
+
     if "error" in r or response.status_code != 200:
         raise RuntimeError(response.text)
+    else:
+        return r
+
 
-    token = r['token']
-    token_expires = r['expires_in']
-    return Roboflow(api_key, token, token_expires)
+def auth(api_key):
+    r = check_key(api_key)
+    w = r['workspace']
+
+    return Roboflow(api_key, w)
 
 
 class Roboflow():
-    def __init__(self, api_key, access_token, token_expires):
+    def __init__(self, api_key):
         self.api_key = api_key
-        self.access_token = access_token
-        self.token_expires = token_expires
-        # TODO: Need an endpoint to retrieve publishable key based on access token/workspace/api key
-        publishable_key_response = requests.get(API_URL + "/key/publishable_key?access_token=" + self.access_token)
-        if publishable_key_response.status_code != 200:
-            raise RuntimeError(publishable_key_response.text)
-        publishable_key_response = publishable_key_response.json()
-        self.publishable_key = publishable_key_response['publishable_key']
-
-    def list_datasets(self):
-        get_datasets_endpoint = API_URL + '/datasets'
-        datasets = requests.get(get_datasets_endpoint + '?access_token=' + self.access_token).json()
-        print(json.dumps(datasets, indent=2))
-        return datasets
-
-    def load(self, dataset_slug):
-        # Get info about dataset being loaded
-        dataset_info = requests.get(API_URL + "/dataset/" + dataset_slug + "?access_token=" + self.access_token)
+        self.auth()
+
+    def auth(self):
+        r = check_key(self.api_key)
+        w = r['workspace']
+
+        self.current_workspace=w
+
+        return self
+
+    def workspace(self, the_workspace=None):
+
+        if the_workspace is None:
+            the_workspace = self.current_workspace
+
+        list_projects = requests.get(API_URL + "/" + the_workspace + '?api_key=' + self.api_key).json()
+
+        return Workspace(list_projects, self.api_key, the_workspace)
+
+    def project(self, project_name, the_workspace=None):
+
+        if the_workspace is None:
+            if "/" in project_name:
+                splitted_project = project_name.rsplit("/")
+                the_workspace, project_name = splitted_project[0], splitted_project[1]
+            else:
+                the_workspace = self.current_workspace
+
+        dataset_info = requests.get(API_URL + "/" + the_workspace + "/" + project_name + "?api_key=" + self.api_key)
+
         # Throw error if dataset isn't valid/user doesn't have permissions to access the dataset
         if dataset_info.status_code != 200:
             raise RuntimeError(dataset_info.text)
-        # Turn dataset info into a json format otherwise
-        dataset_info = dataset_info.json()
-        # Get version info (i.e. version names + numbers)
-        version_info = requests.get(
-            API_URL + "/versions/dataset/" + dataset_slug + "?access_token=" + self.access_token)
-        # Throw error if dataset isn't valid/user doesn't have permissions to access the dataset
-        if version_info.status_code != 200:
-            raise RuntimeError(version_info.text)
-        # Turn dataset version info into a json format otherwise
-        version_info = version_info.json()
-        # Return a project object
-        return Project(self.api_key, dataset_info['id'], dataset_info['type'], version_info['versions'],
-                       self.access_token, self.publishable_key)
+
+        dataset_info = dataset_info.json()['project']
+
+        return Project(self.api_key, dataset_info['id'], dataset_info['type'], dataset_info['versions'])
 
     def __str__(self):
-        json_value = {'api_key': self.api_key, 'auth_token': self.access_token, 'token_expires': self.token_expires}
+        json_value = {'api_key': self.api_key,
+                      'workspace': self.workspace}
         return json.dumps(json_value, indent=2)

roboflow/__init__.py

@@ -1,8 +1,7 @@
 OBJECT_DETECTION_MODEL = "ObjectDetectionModel"
 CLASSIFICATION_MODEL = "ClassificationModel"
 PREDICTION_OBJECT = "Prediction"
-API_URL = "http://localhost:5000"
-
+API_URL = "https://api.roboflow.com"
 from dotenv import load_dotenv
 
 load_dotenv()

roboflow/config.py

@@ -0,0 +1,9 @@
+class Model():
+    def __init__(self, model):
+        self.id = model['id']
+
+        self.endpoint = model['endpoint']
+        self.duration = model['end'] - model['start']
+        self.statistics = {'recall': model['recall'], 'precision': model['precision'], 'map': model['map']}
+
+

roboflow/core/model.py

@@ -2,63 +2,81 @@
 import io
 import json
 import os
-import pathlib
 import urllib
 import warnings
-
 import cv2
 import requests
 from PIL import Image
-
-from roboflow.models.classification import ClassificationModel
-from roboflow.models.object_detection import ObjectDetectionModel
 from roboflow.config import *
+from roboflow.core.version import Version
 
-
+#version class that should return
 class Project():
-    def __init__(self, api_key, dataset_slug, type, versions, access_token, publishable_key):
+    def __init__(self, api_key, dataset_slug, type, workspace):
         self.api_key = api_key
-        self.dataset_slug = dataset_slug
-        self.type = type
-        self.access_token = access_token
-        self.publishable_key = publishable_key
-        # Dictionary of versions + names
-        self.versions_and_names = versions
-        # List of all versions to choose from
-        self.versions = list(int(vers) for vers in versions.keys())
-
-    def model(self, version, local=False):
-        # Check if version number is an available version to choose from
-        if version not in self.versions:
-            raise RuntimeError(
-                str(version) + " is an invalid version; please select a different version from " + str(self.versions))
-
-        # Check whether model exists before initializing model
-        model_info_response = requests.get(
-            API_URL + "/model/" + self.dataset_slug + "/" + str(version) + "?access_token=" + self.access_token)
-        if model_info_response.status_code != 200:
-            raise RuntimeError(model_info_response.text)
-
-        model_info_response = model_info_response.json()
-        # Return appropriate model if model does exist
-        if model_info_response['exists']:
-            if self.type == "object-detection":
-                return ObjectDetectionModel(self.api_key, self.dataset_slug, version, local=local)
-            elif self.type == "classification":
-                return ClassificationModel(self.api_key, self.dataset_slug, version, local=local)
+        self.name = dataset_slug
+        self.category = type
+        self.workspace = workspace
+        self.all_versions = []
+
+    def get_version_information(self):
+
+        slug_splitted = self.name.rsplit("/")
+        p, w = slug_splitted[0], slug_splitted[1]
+
+        dataset_info = requests.get(API_URL + "/" + p + "/" + w + "?api_key=" + self.api_key)
+
+        # Throw error if dataset isn't valid/user doesn't have permissions to access the dataset
+        if dataset_info.status_code != 200:
+            raise RuntimeError(dataset_info.text)
+
+        dataset_info = dataset_info.json()['project']
+        return dataset_info['versions']
+
+    def list_versions(self):
+        version_info = self.get_version_information()
+        print(version_info)
+
+    def versions(self):
+        version_info = self.get_version_information()
+        version_array = []
+        for a_version in version_info:
+            version_object = Version((self.category if 'model' in a_version else None), self.api_key, self.name, a_version['id'], local=False)
+            version_array.append(version_object)
+
+        return version_array
+
+    def version(self, version_number):
+
+        version_info = self.get_version_information()
+
+        for version_object in version_info:
+
+            current_version_num = os.path.basename(version_object['id'])
+            if current_version_num == version_number:
+                vers = Version(self.category, self.api_key, self.name, current_version_num, local=False)
+                return vers
+
+        raise RuntimeError("Version number {} is not found.".format(version_number))
 
     def __image_upload(self, image_path, hosted_image=False, split="train"):
+
         # If image is not a hosted image
         if not hosted_image:
+            project_name = os.path.basename(self.name)
+            image_name = os.path.basename(image_path)
             # Construct URL for local image upload
             self.image_upload_url = "".join([
-                "https://api.roboflow.com/dataset/", self.dataset_slug, "/upload",
+                "https://api.roboflow.com/dataset/", project_name, "/upload",
                 "?api_key=", self.api_key,
-                "&name=" + os.path.basename(image_path),
+                "&name=" + image_name,
                 "&split=" + split
             ])
+
             # Convert to PIL Image
-            image = cv2.cvtColor(image_path, cv2.COLOR_BGR2RGB)
+            img = cv2.imread(image_path)
+            image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
             pilImage = Image.fromarray(image)
             # Convert to JPEG Buffer
             buffered = io.BytesIO()
@@ -67,14 +85,16 @@ def __image_upload(self, image_path, hosted_image=False, split="train"):
             img_str = base64.b64encode(buffered.getvalue())
             img_str = img_str.decode("ascii")
             # Post Base 64 Data to Upload API
+
             response = requests.post(self.image_upload_url, data=img_str, headers={
                 "Content-Type": "application/x-www-form-urlencoded"
             })
 
+
         else:
             # Hosted image upload url
             upload_url = "".join([
-                "https://api.roboflow.com/dataset/" + self.dataset_slug + "/upload",
+                "https://api.roboflow.com/dataset/" + self.name + "/upload",
                 "?api_key=" + self.api_key,
                 "&name=" + os.path.basename(image_path),
                 "&split=" + split,
@@ -83,14 +103,15 @@ def __image_upload(self, image_path, hosted_image=False, split="train"):
             # Get response
             response = requests.post(upload_url)
         # Return response
+
         return response
 
     def __annotation_upload(self, annotation_path, image_id):
         # Get annotation string
         annotation_string = open(annotation_path, "r").read()
         # Set annotation upload url
         self.annotation_upload_url = "".join([
-            "https://api.roboflow.com/dataset/", self.dataset_slug, "/annotate/", image_id,
+            "https://api.roboflow.com/dataset/", self.name, "/annotate/", image_id,
             "?api_key=", self.api_key,
             "&name=" + os.path.basename(annotation_path)
         ])
@@ -107,6 +128,7 @@ def upload(self, image_path=None, annotation_path=None, hosted_image=False, imag
         if image_path is not None:
             # Upload Image Response
             response = self.__image_upload(image_path, hosted_image=hosted_image, split=split)
+
             # Get JSON response values
             try:
                 success, image_id = response.json()['success'], response.json()['id']
@@ -144,9 +166,9 @@ def upload(self, image_path=None, annotation_path=None, hosted_image=False, imag
     def __str__(self):
         # String representation of project
         json_str = {
-            "dataset_slug": self.dataset_slug,
-            "dataset_type": self.type,
-            "dataset_versions": self.versions_and_names
+            "dataset_slug": self.name,
+            "task_type": self.category,
+            "workspace": self.workspace
         }
 
         return json.dumps(json_str, indent=2)

roboflow/core/project.py

@@ -0,0 +1,31 @@
+from roboflow.models.classification import ClassificationModel
+from roboflow.models.object_detection import ObjectDetectionModel
+import os
+import json
+
+
+class Version():
+    def __init__(self, type, api_key, dataset_slug, version, local):
+        self.api_key = api_key
+        self.name = dataset_slug
+        self.version = version
+        self.category = type
+
+        version_without_workspace = os.path.basename(version)
+
+        if self.category == "object-detection":
+            self.model = ObjectDetectionModel(self.api_key, self.name, version_without_workspace, local=local)
+        elif self.category == "classification":
+            self.model = ClassificationModel(self.api_key, self.name, version_without_workspace, local=local)
+        else:
+            self.model = None
+
+    def __str__(self):
+        json_value = {'api_key': self.api_key,
+                      'name': self.name,
+                      'model_type': str(self.model),
+                      'version': self.version}
+        return json.dumps(json_value, indent=2)
+
+
+

roboflow/core/version.py

@@ -0,0 +1,46 @@
+import requests
+from roboflow.core.project import Project
+from roboflow.config import *
+
+class Workspace():
+    def __init__(self, info, api_key, default_workspace):
+
+        self.api_key = api_key
+        self.name = default_workspace
+
+        workspace_info = info['workspace']
+        self.members = workspace_info['members']
+        self.url = workspace_info['url']
+        self.project_list = []
+
+        for value in info['workspace']['projects']:
+            self.project_list.append(value)
+
+    def list_projects(self):
+        print(self.projects)
+
+    def projects(self):
+        projects_array = []
+        for a_project in self.project_list:
+            split = a_project['id'].rsplit("/")
+            workspace, project_name = split[0], split[1]
+            proj = Project(self.api_key, project_name, a_project['type'], workspace)
+            projects_array.append(proj)
+
+        return projects_array
+
+
+    def project(self, project_name):
+
+        if "/" in project_name:
+            raise RuntimeError("Do not re-specify the workspace {} in your project request".format(project_name.rsplit()[0]))
+
+        dataset_info = requests.get(API_URL + "/" + self.name + "/" + project_name + "?api_key=" + self.api_key)
+
+        # Throw error if dataset isn't valid/user doesn't have permissions to access the dataset
+        if dataset_info.status_code != 200:
+            raise RuntimeError(dataset_info.text)
+
+        dataset_info = dataset_info.json()['project']
+
+        return Project(self.api_key, dataset_info['id'], dataset_info['type'], dataset_info['versions'])