Revert "Enhance logging and Unicode handling across the application"

This reverts commit e23b862.

Author: iandjx

agent-backend/src/main.py

@@ -2,7 +2,6 @@
 import signal
 import threading
 import time
-import sys
 
 from asyncio import CancelledError
 
@@ -13,13 +12,6 @@
 from fastapi import FastAPI
 from contextlib import asynccontextmanager
 
-# Configure logging to handle Unicode characters properly
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler(sys.stdout)],
-)
-
 app_logger = logging.getLogger("app")
 
 app_logger.setLevel(LOG_LEVEL.upper())

agent-backend/src/models/sockets.py

@@ -45,5 +45,4 @@ def json(self, **kwargs):
         # Convert the model to a dictionary and replace enum with its value
         d = self.model_dump()
         d["event"] = d["event"].value  # Convert Enum to string
-        # Ensure UTF-8 encoding and handle Unicode characters properly
-        return json.dumps(d, ensure_ascii=False, **kwargs)
+        return json.dumps(d, **kwargs)

agent-backend/src/redisClient/utilities.py

@@ -46,13 +46,14 @@ def insert_hash(self, hash_key: str, key: str, data: list) -> bool:
 
         """
         try:
-            self.redis_client.hset(hash_key, key, json.dumps(data, ensure_ascii=False))
+            self.redis_client.hset(hash_key, key, json.dumps(data))
             return True
         except Exception as err:
             logging.exception(err.args[0])
             logging.exception(traceback.format_exc())
             return False
 
+
     def get(self, key: str) -> str:
         """
         Retrieves the value of a Redis key.
@@ -66,14 +67,13 @@ def get(self, key: str) -> str:
         try:
             value = self.redis_client.get(key)
             if value is not None:
-                return value.decode("utf-8")
+                return value.decode('utf-8')
             else:
                 return None
         except Exception as err:
             logging.exception(err.args[0])
             logging.exception(traceback.format_exc())
             return None
 
-
 if __name__ == "__main__":
     print(f"Running {__name__}")

agent-backend/src/tools/code_execution_docker_notebook_tool.py

@@ -1,11 +1,19 @@
 from .code_execution_tool import CodeExecutionTool
 
 import logging
+import os
+import pathlib
 import re
+import string
+import subprocess
+import sys
+import time
 import inspect
 import json
 
-from typing import Dict, Any
+from concurrent.futures import ThreadPoolExecutor, TimeoutError
+from hashlib import md5
+from typing import Callable, Dict, List, Optional, Tuple, Union, Any
 
 from io import BytesIO
 
@@ -22,11 +30,10 @@ def remove_triple_quotes(text):
     # Substitute found patterns with an empty string
     return re.sub(pattern, "", text)
 
-
 class CodeExecutionUsingDockerNotebookTool(CodeExecutionTool):
 
     def _run(self, args_str: Dict):
-
+        
         args = json.loads(args_str)
         self.execute_function_in_docker(self.function_name, self.code, args)
 
@@ -141,7 +148,9 @@ def jupyter_execution(code) -> tuple[Optional[str], Union[str, Image.Image]]:
             image_list = (
                 ["python:3"]
                 if use_docker is True
-                else [use_docker] if isinstance(use_docker, str) else use_docker
+                else [use_docker]
+                if isinstance(use_docker, str)
+                else use_docker
             )
 
             # Setup Docker image
@@ -181,11 +190,7 @@ def jupyter_execution(code) -> tuple[Optional[str], Union[str, Image.Image]]:
             print(f"Function Execution finished with exit code: {exit_code}")
 
             # Retrieve the logs (output)
-            try:
-                logs = container.logs().decode("utf-8").rstrip()
-            except UnicodeDecodeError:
-                # Fallback to replace problematic characters
-                logs = container.logs().decode("utf-8", errors="replace").rstrip()
+            logs = container.logs().decode("utf-8").rstrip()
 
             # Cleanup
             container.remove()
@@ -194,4 +199,4 @@ def jupyter_execution(code) -> tuple[Optional[str], Union[str, Image.Image]]:
             return logs
         except Exception as e:
             logging.exception(e)
-            raise
+            raise

agent-backend/src/tools/code_execution_tool.py

@@ -1,13 +1,13 @@
 import sys
 from typing import Dict, Type
+from langchain.tools import BaseTool
 import json
 import subprocess
 
-from langchain_core.pydantic_v1 import create_model
+from langchain_core.pydantic_v1 import create_model, Field
 from .global_tools import GlobalBaseTool
 from models.mongo import Tool
 
-
 class CodeExecutionTool(GlobalBaseTool):
     """
     Code execution tool
@@ -16,7 +16,6 @@ class CodeExecutionTool(GlobalBaseTool):
         properties_dict (dict): dictionary of tool.data.parameters.properties { proeprty_name: { type: string | number | boolean, ... } }
                                 this dict is used to create a dynamic pydantic model for "args_schema"
     """
-
     name: str = ""
     description: str = ""
     code: str
@@ -25,10 +24,8 @@ class CodeExecutionTool(GlobalBaseTool):
     args_schema: Type = None
 
     def post_init(self):
-        self.args_schema = create_model(
-            f"{self.function_name}_model",
-            **self.convert_args_dict_to_type(self.properties_dict),
-        )
+        self.args_schema = create_model(f"{self.function_name}_model", **self.convert_args_dict_to_type(self.properties_dict))
+
 
     @classmethod
     def factory(cls, tool: Tool, **kargs):
@@ -37,40 +34,30 @@ def factory(cls, tool: Tool, **kargs):
             description=tool.description,
             function_name=tool.data.name,
             code=tool.data.code,
-            properties_dict=(
-                tool.data.parameters.properties
-                if tool.data.parameters.properties
-                else []
-            ),
+            properties_dict=tool.data.parameters.properties if tool.data.parameters.properties else []
         )
         code_execution_tool.post_init()
         return code_execution_tool
-
+    
     def convert_args_dict_to_type(self, args_schema: Dict):
         args_schema_pydantic = dict()
         for k, v in args_schema.items():
-            args_schema_pydantic[k] = (str, None)
+            args_schema_pydantic[k]=((str, None))
         return args_schema_pydantic
-
+    
     def convert_str_args_to_correct_type(self, args):
         typed_args = dict()
         for k, v in args.items():
             prop = self.properties_dict[k]
             if prop:
-                typed_args[k] = (
-                    bool(v)
-                    if prop.type == "boolean"
-                    else (int(v) if prop.type == "integer" else str(v))
-                )
+                typed_args[k]=bool(v) if prop.type == "boolean" else (int(v) if prop.type == "integer" else str(v))
         return typed_args
-
+    
     def _run(self, args_str: Dict):
         args = json.loads(args_str)
         typed_args = self.convert_str_args_to_correct_type(args)
         indented_code = self.code.replace("\n", "\n    ")
-        function_parameters = ", ".join(
-            args.keys()
-        )  # Extract the keys as parameter names
+        function_parameters = ", ".join(args.keys())  # Extract the keys as parameter names
         formatted_function = f"""def {self.function_name}({function_parameters}):
     {indented_code}
 res = {self.function_name}({", ".join([f"{k}={repr(v)}" for k, v in typed_args.items()])})
@@ -79,16 +66,8 @@ def _run(self, args_str: Dict):
         if sys.platform != "win32":
             formatted_function = formatted_function.replace("\r\n", "\n")
         try:
-            output = subprocess.check_output(
-                ["python", "-c", formatted_function], timeout=5
-            )  # 5 seconds
-            # Decode output as UTF-8 and handle any encoding issues
-            try:
-                decoded_output = output.decode("utf-8")
-            except UnicodeDecodeError:
-                # Fallback to replace problematic characters
-                decoded_output = output.decode("utf-8", errors="replace")
-            print(decoded_output)
-            return decoded_output
+            output = subprocess.check_output(['python', '-c', formatted_function], timeout=5) # 5 seconds
+            print(output)
+            return output
         except TimeoutError:
-            return "Not data returned because the call to Code Execution Tool timedout"
+                return "Not data returned because the call to Code Execution Tool timedout"

agent-backend/src/tools/google_cloud_function.py

@@ -1,19 +1,22 @@
+import sys
 from typing import Dict, Type
+from langchain.tools import BaseTool
 import json
+import subprocess
 
 from init.env_variables import GOOGLE_FUNCTION_LOCATION
-from langchain_core.pydantic_v1 import create_model
+from langchain_core.pydantic_v1 import create_model, Field
 from .global_tools import GlobalBaseTool
 from models.mongo import Tool
 
 
 import requests
+import os
 import google.oauth2.id_token
 import google.auth.transport.requests
 from google.cloud import logging_v2
 from google.api_core.exceptions import GoogleAPIError
 
-
 class GoogleCloudFunctionTool(GlobalBaseTool):
     """
     Google Cloud Function execution tool
@@ -23,7 +26,6 @@ class GoogleCloudFunctionTool(GlobalBaseTool):
         properties_dict (dict): dictionary of tool.data.parameters.properties { property_name: { type: string | number | boolean, ... } }
                                 this dict is used to create a dynamic pydantic model for "args_schema"
     """
-
     name: str = ""
     description: str = ""
     function_name: str
@@ -32,10 +34,7 @@ class GoogleCloudFunctionTool(GlobalBaseTool):
     function_id: str = None
 
     def post_init(self):
-        self.args_schema = create_model(
-            f"{self.function_name}_model",
-            **self.convert_args_dict_to_type(self.properties_dict),
-        )
+        self.args_schema = create_model(f"{self.function_name}_model", **self.convert_args_dict_to_type(self.properties_dict))
 
     @classmethod
     def factory(cls, tool: Tool, **kargs):
@@ -44,16 +43,12 @@ def factory(cls, tool: Tool, **kargs):
             description=tool.description,
             function_name=tool.data.name,
             code=tool.data.code,
-            properties_dict=(
-                tool.data.parameters.properties
-                if tool.data.parameters.properties
-                else []
-            ),
-            function_id=str(tool.functionId),
+            properties_dict=tool.data.parameters.properties if tool.data.parameters.properties else [],
+            function_id=str(tool.functionId)
         )
         google_cloud_function_tool.post_init()
         return google_cloud_function_tool
-
+    
     def convert_args_dict_to_type(self, args_schema: Dict):
         args_schema_pydantic = dict()
         for k, v in args_schema.items():
@@ -65,29 +60,25 @@ def convert_str_args_to_correct_type(self, args):
         for k, v in args.items():
             prop = self.properties_dict.get(k)
             if prop:
-                typed_args[k] = (
-                    bool(v)
-                    if prop.type == "boolean"
-                    else (int(v) if prop.type == "integer" else str(v))
-                )
+                typed_args[k] = bool(v) if prop.type == "boolean" else (int(v) if prop.type == "integer" else str(v))
                 return typed_args
 
     def query_log_entries(self, limit):
         client = logging_v2.Client()
         filter_str = f'resource.type="cloud_run_revision" severity>=WARNING resource.labels.service_name="function-{self.function_id}"'
         try:
             entries = client.list_entries(
-                filter_=filter_str, page_size=limit, order_by="timestamp desc"
+                filter_=filter_str,
+                page_size=limit,
+                order_by='timestamp desc'
             )
             # Convert entries to a list to access the entries
             entries_list = list(entries)
-            combined_payloads = "\n".join(
-                entry.payload for entry in entries_list if entry.payload is not None
-            )
+            combined_payloads = '\n'.join(entry.payload for entry in entries_list if entry.payload is not None)
             return combined_payloads
         except GoogleAPIError as e:
             print(f"An error occurred: {e}")
-            return ""  # TODO: what is a sensible value here?
+            return "" # TODO: what is a sensible value here?
 
     def _run(self, **kwargs):
         typed_args = self.convert_str_args_to_correct_type(kwargs)
@@ -100,11 +91,8 @@ def _run(self, **kwargs):
             TOKEN = google.oauth2.id_token.fetch_id_token(request, audience)
             r = requests.post(
                 audience,
-                headers={
-                    "Authorization": f"Bearer {TOKEN}",
-                    "Content-Type": "application/json",
-                },
-                data=json.dumps(typed_args, ensure_ascii=False),
+                headers={'Authorization': f"Bearer {TOKEN}", "Content-Type": "application/json"},
+                data=json.dumps(typed_args)
             )
             print(f"status code: {r.status_code}")
             print(f"response body: {r.text}")