Updates

Author: eob

src/steamship/app/lambda_handler.py

@@ -20,24 +20,29 @@ def _handler(event: Dict, context: Dict = None) -> Response:
                 configDict=event.get("clientConfig", None)
             )
         except SteamshipError as se:
+            logging.error(se)
             return Response.from_obj(se)
         except Exception as ex:
+            logging.error(ex)
             return Response.error(code=500, message="Plugin/App handler was unable to create Steamship client.", exception=ex)
 
         app = None
 
         try:
             request = Request.from_dict(event)
         except SteamshipError as se:
+            logging.error(se)
             return Response.from_obj(se)
         except Exception as ex:
+            logging.error(ex)
             return Response.error(code=500, message="Plugin/App handler was unable to parse inbound request.", exception=ex)
 
         try:
             app = App(client=client, config=request.invocation.config)
         except SteamshipError as se:
             return Response.from_obj(se)
         except Exception as ex:
+            logging.error(ex)
             return Response.error(code=500, message="Handler was unable to initialize plugin/app.", exception=ex)
 
         if app is None:
@@ -47,9 +52,17 @@ def _handler(event: Dict, context: Dict = None) -> Response:
             response = app(request)
             return Response.from_obj(response)
         except SteamshipError as se:
+            logging.error(se)
             return Response.from_obj(se)
         except Exception as ex:
-            return Response.error(code=500, message="Handler was unable to run app/plugin method", exception=ex)
+            logging.error(ex)
+            appVerb = None
+            appPath = None
+            if request:
+                if request.invocation:
+                    appPath = request.invocation.appPath
+                    appVerb = request.invocation.httpVerb
+            return Response.error(code=500, message="Handler was unable to run app/plugin method {} {}".format(appVerb, appPath), exception=ex)
 
     def handler(event: Dict, context: Dict = None) -> dict:
         response = _handler(event, context)

src/steamship/app/request.py

@@ -59,7 +59,6 @@ class Request:
     def from_dict(d: dict) -> "Request":
         invocation = Invocation.from_dict(d.get('invocation', dict()))
         clientConfig = Configuration.from_dict(d.get('clientConfig', dict()))
-        logging.info("App layer got invocation {} {}".format(type(invocation), invocation))
         return Request(
             clientConfig=clientConfig,
             invocation=invocation

src/steamship/app/response.py

@@ -2,16 +2,21 @@
 import io
 import logging
 from dataclasses import dataclass
-from typing import Dict, Any, Generic, TypeVar
+from typing import Dict, Any, Generic, TypeVar, Union
 
 from steamship.base.binary_utils import flexi_create
 from steamship.base import SteamshipError
 from steamship.base.tasks import Task, TaskState
+from steamship.base.mime_types import MimeTypes, ContentEncodings
 
 
 @dataclass
 class Http():
     status: int = None
+    # If true, we're signaling to the Steamship Proxy that the `data` field of the SteamshipResponse object
+    # has been wrapped in base64. In this situation, we can return the bytes within directly to the Proxy
+    # caller without interpreting it.
+    base64Wrapped: bool = None
     headers: Dict[str, str] = None
 
 T = TypeVar('T')
@@ -31,7 +36,7 @@ def __init__(
             data: any = None,
             string: str = None,
             json: Any = None,
-            bytes: io.BytesIO = None,
+            bytes: Union[bytes, io.BytesIO] = None,
             mimeType = None
     ):
         # Note:
@@ -44,7 +49,7 @@ def __init__(
 
         # Handle the core data
         try:
-            data, mimeType = flexi_create(
+            data, mimeType, encoding = flexi_create(
                 data=data,
                 string=string,
                 json=json,
@@ -54,17 +59,27 @@ def __init__(
 
             self.data = data
 
-            # Set the mime type if not already set
+            if mimeType is None:
+                mimeType = MimeTypes.BINARY
+
             if mimeType is not None:
+                if self.http.headers is None:
+                    self.http.headers = dict()
                 self.http.headers["Content-Type"] = mimeType
+
+            if encoding == ContentEncodings.BASE64:
+                self.http.base64Wrapped = True
+
         except Exception as ex:
+            logging.error("Exception within Response.__init__. {}".format(ex))
             if error is not None:
                 if error.message:
                     error.message = "{}. Also found error - unable to serialize data to response. {}".format(error.message, ex)
                 else:
                     error.message = "Unable to serialize data to response. {}".format(ex)
             else:
                 error = SteamshipError(message="Unable to serialize data to response. {}".format(ex))
+            logging.error(error)
 
         # Handle the task provided
         if status is None:

src/steamship/base/binary_utils.py

@@ -2,9 +2,11 @@
 import dataclasses
 import io
 import json as jsonlib
-from typing import Any, Tuple
+import logging
+from typing import Any, Tuple, Union
+from steamship.base.error import SteamshipError
 
-from steamship.base.mime_types import MimeTypes
+from steamship.base.mime_types import MimeTypes, ContentEncodings
 
 
 def guess_mime(obj: Any, provided_mime: str = None) -> str:
@@ -14,15 +16,24 @@ def guess_mime(obj: Any, provided_mime: str = None) -> str:
         return MimeTypes.TXT
     return MimeTypes.BINARY
 
+def to_b64(obj: Any) -> str:
+    ret_bytes = obj
+    if type(obj) == bytes:
+        ret_bytes = obj
+    elif type(obj) == str:
+        ret_bytes = ret_bytes.encode('utf-8')
+    else:
+        ret_bytes = str(obj).encode('utf-8')
+    return base64.b64encode(ret_bytes).decode('utf-8')
 
 def flexi_create(
         base64string: str = None,
         data: Any = None,
         string: str = None,
         json: Any = None,
-        bytes: io.BytesIO = None,
+        bytes: Union[bytes, io.BytesIO] = None,
         mimeType=None,
-        alwaysBase64=False) -> Tuple[Any, str]:
+        alwaysBase64=False) -> Tuple[Any, Union[None, str], Union[None, str]]:
     """
     It's convenient for some constructors to accept a variety of input types:
     - data (your chocie)
@@ -33,38 +44,46 @@ def flexi_create(
     .. And have them all homogenized.
     """
 
-    if base64string is not None:
-        return base64string, mimeType or MimeTypes.BINARY
+    try:
+        if base64string is not None:
+            logging.error("B64")
+            return base64string, mimeType or MimeTypes.BINARY, ContentEncodings.BASE64
 
-    ret_data = None
-    ret_mime = None
+        ret_data = None # the body of the result
+        ret_mime = None # for the Content-Type field
+        ret_encoding = None # for the Content-Encoding field
+        is_b64 = False
 
-    if data is not None:
-        ret_data, ret_mime = data, guess_mime(data, mimeType)
+        if data is not None:
+            ret_data, ret_mime = data, mimeType or guess_mime(data, mimeType)
 
-    elif string is not None:
-        ret_data, ret_mime = string, mimeType or MimeTypes.TXT
+        elif string is not None:
+            ret_data, ret_mime = string, mimeType or MimeTypes.TXT
 
-    elif json is not None:
-        if dataclasses.is_dataclass(json):
-            ret_data, ret_mime = jsonlib.dumps(dataclasses.asdict(json)), mimeType or MimeTypes.JSON
-        else:
-            ret_data, ret_mime = jsonlib.dumps(json), mimeType or MimeTypes.JSON
+        elif json is not None:
+            if dataclasses.is_dataclass(json):
+                ret_data, ret_mime = dataclasses.asdict(json), mimeType or MimeTypes.JSON
+            else:
+                ret_data, ret_mime = json, mimeType or MimeTypes.JSON
 
-    if ret_data is not None:
-        if alwaysBase64 is False:
-            return ret_data, ret_mime
+        elif bytes is not None:
+            if isinstance(bytes, io.BytesIO):
+                bytes = bytes.getvalue() # Turn it into regular bytes
+            ret_data, ret_mime = base64.b64encode(bytes).decode('utf-8'), mimeType or ret_mime or MimeTypes.BINARY
+            is_b64 = True
+            ret_encoding = ContentEncodings.BASE64
 
-        ret_bytes = ret_data
-        if type(ret_data) == bytes:
-            ret_bytes = ret_data
-        elif type(ret_data) == str:
-            ret_bytes = ret_bytes.encode('utf-8')
-        else:
-            ret_bytes = str(ret_data).encode('utf-8')
-        return base64.b64encode(ret_bytes).decode('utf-8'), ret_mime or MimeTypes.BINARY
+        if ret_data is not None:
+            logging.error("had ret data")
+            if alwaysBase64 is False:
+                return ret_data, ret_mime, ret_encoding
+            if is_b64 is True:
+                return ret_data, ret_mime, ContentEncodings.BASE64
+            else:
+                return to_b64(ret_data), ret_mime or MimeTypes.BINARY, ContentEncodings.BASE64
 
-    if bytes is not None:
-        return base64.b64encode(bytes).decode('utf-8'), mimeType or MimeTypes.BINARY
-
-    return None, None
+        return None, None, None
+    except Exception as ex:
+        logging.error("Exception thrown trying to encode data")
+        logging.error(ex)
+        raise SteamshipError(message="There was an exception thrown while trying to encode your app/plugin data.", error=ex)

src/steamship/base/client.py

@@ -248,8 +248,9 @@ def call(
         url = self._url(
             appCall=appCall,
             appOwner=appOwner,
-            operation=operation
+            operation=operation,
         )
+
         headers = self._headers(
             spaceId=spaceId,
             spaceHandle=spaceHandle,

src/steamship/base/mime_types.py

@@ -17,6 +17,8 @@ class MimeTypes:
     RTF = "application/rtf"
     BINARY = "application/octet-stream"
 
+class ContentEncodings:
+    BASE64 = "base64"
 
 TEXT_MIME_TYPES = [
     MimeTypes.TXT,

src/steamship/base/tasks.py

@@ -291,8 +291,14 @@ def update(self, other: "Task"):
             self.maxRetries = None
             self.retries = None
 
-    def add_comment(self, externalId: str = None, externalType: str = None, externalGroup: str = None,
-                    metadata: any = None, upsert: bool = True) -> IResponse[TaskComment]:
+    def add_comment(
+            self,
+            externalId: str = None,
+            externalType: str = None,
+            externalGroup: str = None,
+            metadata: any = None,
+            upsert: bool = True
+    ) -> IResponse[TaskComment]:
         return TaskComment.create(
             client=self.client,
             taskId=self.taskId,

src/steamship/data/app_instance.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 from typing import Dict
 
+from steamship.data.space import Space
 from steamship.base import Client, Request
 
 
@@ -32,6 +33,7 @@ class AppInstance:
     invocationURL: str = None
     config: Dict[str, any] = None
     spaceId: str = None
+    spaceHandle: str = None
 
     @staticmethod
     def from_dict(d: any, client: Client = None) -> "AppInstance":
@@ -49,7 +51,8 @@ def from_dict(d: any, client: Client = None) -> "AppInstance":
             userId=d.get('userId', None),
             invocationURL=d.get('invocationURL', None),
             config= d.get('config', None),
-            spaceId= d.get('spaceId', None)
+            spaceId= d.get('spaceId', None),
+            spaceHandle= d.get('spaceHandle', None)
         )
 
     @staticmethod
@@ -86,11 +89,23 @@ def delete(self) -> "AppInstance":
             expect=AppInstance
         )
 
+    def load_missing_vals(self):
+        if self.client is not None and self.spaceHandle is None and self.spaceId is not None:
+            # Get the spaceHandle
+            space = Space.get(self.client, id=self.spaceId)
+            if space and space.data:
+                self.spaceHandle = space.data.handle
+
     def get(self, path: str, **kwargs):
+        self.load_missing_vals()
         if path[0] == '/':
             path = path[1:]
         return self.client.get(
-            '/_/_/{}'.format(path),
+            '/{}/{}/{}'.format(
+                self.spaceHandle or "/",
+                self.handle or "/",
+                path
+            ),
             payload=kwargs,
             appCall=True,
             appOwner=self.userHandle,
@@ -100,10 +115,15 @@ def get(self, path: str, **kwargs):
         )
 
     def post(self, path: str, **kwargs):
+        self.load_missing_vals()
         if path[0] == '/':
             path = path[1:]
         return self.client.post(
-            '/_/_/{}'.format(path),
+            '/{}/{}/{}'.format(
+                self.spaceHandle or "/",
+                self.handle or "/",
+                path
+            ),
             payload=kwargs,
             appCall=True,
             appOwner=self.userHandle,

src/steamship/data/file.py

@@ -173,7 +173,7 @@ def __init__(
                 json: io.BytesIO = None,
                 mimeType: str = None
         ):
-            data, mimeType = flexi_create(
+            data, mimeType, encoding = flexi_create(
                 data=data,
                 string=string,
                 json=json,