SG-39698 Remove try/except sgutil blocks and ensure_ methods (#297)

Author: eduardoChaucaGallegos

python/tk_framework_desktopserver/command.py

@@ -19,11 +19,6 @@
 
 import sgtk.util
 
-try:
-    from tank_vendor import sgutils
-except ImportError:
-    from tank_vendor import six as sgutils
-
 logger = get_logger(__name__)
 
 
@@ -49,7 +44,9 @@ def run(self):
         is closed.
         """
         while True:
-            line = sgutils.ensure_str(self.pipe.readline())  # blocking read
+            line = self.pipe.readline()  # blocking read
+            if isinstance(line, bytes):
+                line = line.decode("utf-8")
             if line == "":
                 break
             self.target_queue.put(line)

python/tk_framework_desktopserver/server.py

@@ -27,11 +27,6 @@
 
 from sgtk.platform.qt import QtCore
 
-try:
-    from tank_vendor import sgutils
-except ImportError:
-    from tank_vendor import six as sgutils
-
 logger = get_logger(__name__)
 
 
@@ -107,8 +102,8 @@ def __init__(
         if encrypt:
             # urandom is considered cryptographically secure as it calls the OS's CSRNG, so we can
             # use that to generate our own server id.
-            self._ws_server_id = sgutils.ensure_str(
-                base64.urlsafe_b64encode(os.urandom(16))
+            self._ws_server_id = base64.urlsafe_b64encode(os.urandom(16)).decode(
+                "utf-8"
             )
         else:
             self._ws_server_id = None

python/tk_framework_desktopserver/server_protocol.py

@@ -24,11 +24,6 @@
 from .message_host import MessageHost
 from .process_manager import ProcessManager
 
-try:
-    from tank_vendor import sgutils
-except ImportError:
-    from tank_vendor import six as sgutils
-
 logger = get_logger(__name__)
 
 
@@ -166,7 +161,9 @@ def _on_message(self, payload, is_binary):
                 logger.exception("Unexpected error while decrypting:")
                 return
 
-        decoded_payload = sgutils.ensure_str(payload)
+        decoded_payload = (
+            payload.decode("utf-8") if isinstance(payload, bytes) else str(payload)
+        )
 
         # Special message to get protocol version for this protocol. This message doesn't follow the
         # standard message format as it doesn't require a protocol version to be retrieved and is
@@ -360,7 +357,12 @@ def _retrieve_server_secret(self):
             response = shotgun._call_rpc(
                 "retrieve_ws_server_secret", {"ws_server_id": self.factory.ws_server_id}
             )
-            ws_server_secret = sgutils.ensure_str(response["ws_server_secret"])
+            ws_server_secret = response["ws_server_secret"]
+            ws_server_secret = (
+                response["ws_server_secret"].decode("utf-8")
+                if isinstance(ws_server_secret, bytes)
+                else ws_server_secret
+            )
             # FIXME: Server doesn't seem to provide a properly padded string. The Javascript side
             # doesn't seem to complain however, so I'm not sure whose implementation is broken.
             if ws_server_secret[-1] != "=":
@@ -447,13 +449,11 @@ def json_reply(self, data):
         :param data: Object Data that will be converted to JSON and sent to client.
         """
         # ensure_ascii allows unicode strings.
-        payload = sgutils.ensure_binary(
-            json.dumps(
-                data,
-                ensure_ascii=True,
-                default=self._json_date_handler,
-            )
-        )
+        payload = json.dumps(
+            data,
+            ensure_ascii=True,
+            default=self._json_date_handler,
+        ).encode("utf-8")
 
         if self._fernet:
             payload = self._fernet.encrypt(payload)

python/tk_framework_desktopserver/shotgun/api_v2.py

@@ -34,11 +34,6 @@
 from . import constants
 from .. import command
 
-try:
-    from tank_vendor import sgutils
-except ImportError:
-    from tank_vendor import six as sgutils
-
 logger = sgtk.platform.get_logger(__name__)
 
 
@@ -316,9 +311,8 @@ def _execute_action(self, data):
         # message that wasn't on the first line of text before any newlines.
         for line in stdout.split("\n") + stderr.split("\n"):
             if line.startswith(tag):
-                filtered_output.append(
-                    sgutils.ensure_str(base64.b64decode(line[tag_length:]))
-                )
+                decoded = base64.b64decode(line[tag_length:]).decode("utf-8")
+                filtered_output.append(decoded)
 
         filtered_output_string = "\n".join(filtered_output)
 
@@ -632,8 +626,9 @@ def _get_actions(self, data):
                 if cached_data:
                     # The value will be bytes
                     # ensure_str doesn't accept a buffer as input
-                    string_data = sgutils.ensure_str(cached_data[0])
-
+                    string_data = cached_data[0]
+                    if isinstance(string_data, bytes):
+                        string_data = string_data.decode("utf-8")
                     try:
                         decoded_data = sgtk.util.json.loads(string_data)
                     except Exception:
@@ -1030,7 +1025,7 @@ def _write_commands_to_db(self, commands, config_data, contents_hash):
 
                     connection.commit()
 
-            commands_blob = sqlite3.Binary(sgutils.ensure_binary(json.dumps(commands)))
+            commands_blob = sqlite3.Binary(json.dumps(commands).encode("utf-8"))
 
             # Since we're likely to be updating out-of-date cached data more
             # often than we're going to be inserting new rows into the cache,
@@ -1265,10 +1260,10 @@ def _get_contents_hash(self, config_descriptor, entities):
         logger.debug("Contents data to be used in hash generation: %s", json_data)
 
         hash_data = hashlib.md5()
-        hash_data.update(sgutils.ensure_binary(json_data))
+        hash_data.update(json_data.encode("utf-8"))
         # Base64 encode the digest, will is a binary string
         # in Python 3. This ensures we can always encode it to a str.
-        return sgutils.ensure_str(base64.b64encode(hash_data.digest()))
+        return base64.b64encode(hash_data.digest()).decode("utf-8")
 
     def _get_entities_from_payload(self, data):
         """
@@ -1541,7 +1536,7 @@ def _get_exception_message(self):
         )
 
         if self._global_debug:
-            message = sgutils.ensure_binary(html.escape(traceback.format_exc()))
+            message = html.escape(traceback.format_exc()).encode("utf-8")
 
         return message
 
@@ -2178,7 +2173,7 @@ def _legacy_sanitize_output(self, out):
                 line = re.sub(bold_match, "*", line)
                 sanitized.append(line)
 
-        return sgutils.ensure_binary(html.escape("\n".join(sanitized)))
+        return html.escape("\n".join(sanitized)).encode("utf-8")
 
     @sgtk.LogManager.log_timing
     def _process_commands(self, commands, project, entities):

python/tk_framework_desktopserver/shotgun/scripts/execute_command.py

@@ -39,7 +39,7 @@ def format(self, *args, **kwargs):
         result = super().format(*args, **kwargs)
         return "%s%s" % (
             LOGGING_PREFIX,
-            sgutils.ensure_str(base64.b64encode(sgutils.ensure_binary(result))),
+            base64.b64encode(result.encode("utf-8")).decode("utf-8"),
         )
 
 
@@ -322,7 +322,6 @@ def execute(
     # We need to make sure that we're not introducing unicode into the
     # environment. This cropped up with some studio-team apps that ended
     # up causing some hangs on launch.
-    core_root = sgutils.ensure_str(core_root)
 
     sgtk.util.prepend_path_to_env_var(
         "PYTHONPATH",
@@ -357,11 +356,10 @@ def execute(
     # match the project's config path instead.
     config_path = engine.sgtk.pipeline_configuration.get_path()
 
-    # We need to make sure that we don't introduce unicode into the
-    # environment. This appears to happen at times, likely due to some
-    # component of the path built by pipeline_configuration "infecting"
-    # the resulting aggregate path.
-    config_path = sgutils.ensure_str(config_path)
+    # Ensure that no unicode characters are introduced into the environment.
+    # This sometimes happens when part of the path from pipeline_configuration
+    # "contaminates" the final aggregated path.
+    config_path = str(config_path)
 
     os.environ["TANK_CURRENT_PC"] = config_path
 
@@ -389,11 +387,6 @@ def execute(
     try:
         sys.path = [arg_data["sys_path"]] + sys.path
         import sgtk
-
-        try:
-            from tank_vendor import sgutils
-        except ImportError:
-            from tank_vendor import six as sgutils
     finally:
         sys.path = original_sys_path