[SDK-430] Address export test findings (#1288)

Author: kopreschko

labelbox/orm/db_object.py

@@ -270,14 +270,37 @@ def delete(self):
 
 
 def experimental(fn):
+    """Decorator used to mark functions that are experimental. This means that
+    the interface could change. This decorator will check if the client has
+    experimental features enabled. If not, it will raise a runtime error.
+    """
+    is_static = isinstance(fn, staticmethod)
 
     @wraps(fn)
-    def wrapper(self, *args, **kwargs):
-        if not self.client.enable_experimental:
-            raise Exception(
-                f"This function {fn.__name__} relies on a experimental feature in the api. This means that the interface could change."
-                " Set `enable_experimental=True` in the client to enable use of experimental functions."
-            )
-        return fn(self, *args, **kwargs)
+    def wrapper(*args, **kwargs):
+        client = None
+        wrapped_fn = None
+        if is_static:
+            # assumes that the first argument is the client, needs modification if that changes
+            if len(args) >= 1:
+                client = args[0]
+            elif "client" in kwargs:
+                client = kwargs["client"]
+            else:
+                raise ValueError(
+                    f"Static method {fn.__name__} must have a client passed in as the first "
+                    f"argument or as a keyword argument.")
+            wrapped_fn = fn.__func__
+        else:
+            client = args[0].client
+            wrapped_fn = fn
+
+        if not client.enable_experimental:
+            raise RuntimeError(
+                f"This function {fn.__name__} relies on a experimental feature in the api. "
+                f"This means that the interface could change. "
+                f"Set `enable_experimental=True` in the client to enable use of "
+                f"experimental functions.")
+        return wrapped_fn(*args, **kwargs)
 
     return wrapper

labelbox/schema/export_task.py

@@ -124,8 +124,11 @@ def _find_json_object_offsets(self, data: str) -> List[Tuple[int, int]]:
                         object_offsets.append((0, index - 1))
             elif char == "}" and stack:
                 stack.pop()
-                if len(stack) == 0 and data[
-                        index + 1] == "\n" and current_object_start is not None:
+                # this covers cases where the last object is either followed by a newline or
+                # it is missing
+                if len(stack) == 0 and (len(data) == index + 1 or
+                                        data[index + 1] == "\n"
+                                       ) and current_object_start is not None:
                     object_offsets.append((current_object_start, index + 1))
                     current_object_start = None
 
@@ -143,8 +146,8 @@ def convert(
         offsets = self._find_json_object_offsets(raw_data)
         for line, (offset_start, offset_end) in enumerate(offsets):
             yield JsonConverterOutput(
-                current_offset + offset_start,
-                current_line + line,
+                current_offset=current_offset + offset_start,
+                current_line=current_line + line,
                 json_str=raw_data[offset_start:offset_end + 1].strip(),
             )
 
@@ -549,32 +552,30 @@ def _get_metadata_header(
         res = res["task"]["exportMetadataHeader"]
         return _MetadataHeader(**res) if res else None
 
-    def get_total_file_size(self, task_id: str,
-                            stream_type: StreamType) -> Union[int, None]:
+    def get_total_file_size(self, stream_type: StreamType) -> Union[int, None]:
         """Returns the total file size for a specific task."""
         if not self._task.status in ["COMPLETE", "FAILED"]:
             raise ExportTask.TaskNotReadyException("Task is not ready yet")
-        header = ExportTask._get_metadata_header(self._task.client, task_id,
-                                                 stream_type)
+        header = ExportTask._get_metadata_header(self._task.client,
+                                                 self._task.uid, stream_type)
         return header.total_size if header else None
 
-    def get_total_lines(self, task_id: str,
-                        stream_type: StreamType) -> Union[int, None]:
+    def get_total_lines(self, stream_type: StreamType) -> Union[int, None]:
         """Returns the total file size for a specific task."""
         if not self._task.status in ["COMPLETE", "FAILED"]:
             raise ExportTask.TaskNotReadyException("Task is not ready yet")
-        header = ExportTask._get_metadata_header(self._task.client, task_id,
-                                                 stream_type)
+        header = ExportTask._get_metadata_header(self._task.client,
+                                                 self._task.uid, stream_type)
         return header.total_lines if header else None
 
     def has_result(self) -> bool:
         """Returns whether the task has a result."""
-        total_size = self.get_total_file_size(self._task.uid, StreamType.RESULT)
+        total_size = self.get_total_file_size(StreamType.RESULT)
         return total_size is not None and total_size > 0
 
     def has_errors(self) -> bool:
         """Returns whether the task has errors."""
-        total_size = self.get_total_file_size(self._task.uid, StreamType.ERRORS)
+        total_size = self.get_total_file_size(StreamType.ERRORS)
         return total_size is not None and total_size > 0
 
     @overload