Restore files that only have linting changes

Author: sahilds1

server/api/services/tools/tools.py

@@ -1,8 +1,6 @@
+from django.db import connection
 from typing import Dict, Any, Callable, List
 from dataclasses import dataclass
-
-from django.db import connection
-
 from .database import ask_database, get_database_info
 
 database_schema_dict = get_database_info(connection)
@@ -13,15 +11,13 @@
     ]
 )
 
-
 @dataclass
 class ToolFunction:
     name: str
     func: Callable
     description: str
     parameters: Dict[str, Any]
 
-
 def create_tool_dict(tool: ToolFunction) -> Dict[str, Any]:
     return {
         "type": "function",
@@ -32,11 +28,10 @@ def create_tool_dict(tool: ToolFunction) -> Dict[str, Any]:
                 "type": "object",
                 "properties": tool.parameters,
                 "required": list(tool.parameters.keys()),
-            },
-        },
+            }
+        }
     }
 
-
 TOOL_FUNCTIONS = [
     ToolFunction(
         name="ask_database",
@@ -61,58 +56,60 @@ def create_tool_dict(tool: ToolFunction) -> Dict[str, Any]:
                 SQL should be written using this database schema:
                 {database_schema_string}
                 The query should be returned in plain text, not in JSON.
-                """,
+                """
             }
-        },
+        }
     ),
 ]
 
 # Automatically generate the tool_functions dictionary and tools list
-tool_functions: Dict[str, Callable] = {tool.name: tool.func for tool in TOOL_FUNCTIONS}
-
-tools: List[Dict[str, Any]] = [create_tool_dict(tool) for tool in TOOL_FUNCTIONS]
+tool_functions: Dict[str, Callable] = {
+    tool.name: tool.func for tool in TOOL_FUNCTIONS
+}
 
+tools: List[Dict[str, Any]] = [
+    create_tool_dict(tool) for tool in TOOL_FUNCTIONS
+]
 
 def validate_tool_inputs(tool_function_name, tool_arguments):
     """Validate the inputs for the execute_tool function."""
     if not isinstance(tool_function_name, str) or not tool_function_name:
         raise ValueError("Invalid tool function name")
-
+    
     if not isinstance(tool_arguments, dict):
         raise ValueError("Tool arguments must be a dictionary")
-
+    
     # Check if the tool_function_name exists in the tools
     tool = next((t for t in tools if t["function"]["name"] == tool_function_name), None)
     if not tool:
         raise ValueError(f"Tool function '{tool_function_name}' does not exist")
-
+    
     # Validate the tool arguments based on the tool's parameters
     parameters = tool["function"].get("parameters", {})
     required_params = parameters.get("required", [])
     for param in required_params:
         if param not in tool_arguments:
             raise ValueError(f"Missing required parameter: {param}")
-
+    
     # Check if the parameter types match the expected types
     properties = parameters.get("properties", {})
     for param, prop in properties.items():
-        expected_type = prop.get("type")
+        expected_type = prop.get('type')
         if param in tool_arguments:
-            if expected_type == "string" and not isinstance(tool_arguments[param], str):
+            if expected_type == 'string' and not isinstance(tool_arguments[param], str):
                 raise ValueError(f"Parameter '{param}' must be of type string")
-
-
+            
 def execute_tool(function_name: str, arguments: Dict[str, Any]) -> str:
     """
     Execute the appropriate function based on the function name.
-
+    
     :param function_name: The name of the function to execute
     :param arguments: A dictionary of arguments to pass to the function
     :return: The result of the function execution
     """
     # Validate tool inputs
     validate_tool_inputs(function_name, arguments)
-
+    
     try:
         return tool_functions[function_name](**arguments)
     except Exception as e:

server/api/views/conversations/urls.py

@@ -1,12 +1,13 @@
 from django.urls import path, include
-from rest_framework.routers import DefaultRouter
-
 from api.views.conversations import views
+from rest_framework.routers import DefaultRouter
+# from views import ConversationViewSet
 
 router = DefaultRouter()
-router.register(r"conversations", views.ConversationViewSet, basename="conversation")
+router.register(r'conversations', views.ConversationViewSet,
+                basename='conversation')
 
 urlpatterns = [
     path("chatgpt/extract_text/", views.extract_text, name="post_web_text"),
-    path("chatgpt/", include(router.urls)),
+    path("chatgpt/", include(router.urls))
 ]

server/api/views/conversations/views.py

@@ -1,7 +1,3 @@
-import os
-import json
-import logging
-
 from rest_framework.response import Response
 from rest_framework import viewsets, status
 from rest_framework.decorators import action
@@ -13,8 +9,10 @@
 import requests
 from openai import OpenAI
 import tiktoken
+import os
+import json
+import logging
 from django.views.decorators.csrf import csrf_exempt
-
 from .models import Conversation, Message
 from .serializers import ConversationSerializer
 from ...services.tools.tools import tools, execute_tool
@@ -69,7 +67,6 @@ def get_tokens(string: str, encoding_name: str) -> str:
 
 class OpenAIAPIException(APIException):
     """Custom exception for OpenAI API errors."""
-
     status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
     default_detail = "An error occurred while communicating with the OpenAI API."
     default_code = "openai_api_error"
@@ -98,29 +95,26 @@ def destroy(self, request, *args, **kwargs):
         self.perform_destroy(instance)
         return Response(status=status.HTTP_204_NO_CONTENT)
 
-    @action(detail=True, methods=["post"])
+    @action(detail=True, methods=['post'])
     def continue_conversation(self, request, pk=None):
         conversation = self.get_object()
-        user_message = request.data.get("message")
-        page_context = request.data.get("page_context")
+        user_message = request.data.get('message')
+        page_context = request.data.get('page_context')
 
         if not user_message:
             return Response({"error": "Message is required"}, status=400)
 
         # Save user message
-        Message.objects.create(
-            conversation=conversation, content=user_message, is_user=True
-        )
+        Message.objects.create(conversation=conversation,
+                               content=user_message, is_user=True)
 
         # Get ChatGPT response
         chatgpt_response = self.get_chatgpt_response(
-            conversation, user_message, page_context
-        )
+            conversation, user_message, page_context)
 
         # Save ChatGPT response
-        Message.objects.create(
-            conversation=conversation, content=chatgpt_response, is_user=False
-        )
+        Message.objects.create(conversation=conversation,
+                               content=chatgpt_response, is_user=False)
 
         # Generate or update title if it's the first message or empty
         if conversation.messages.count() <= 2 or not conversation.title:
@@ -129,31 +123,25 @@ def continue_conversation(self, request, pk=None):
 
         return Response({"response": chatgpt_response, "title": conversation.title})
 
-    @action(detail=True, methods=["patch"])
+    @action(detail=True, methods=['patch'])
     def update_title(self, request, pk=None):
         conversation = self.get_object()
-        new_title = request.data.get("title")
+        new_title = request.data.get('title')
 
         if not new_title:
-            return Response(
-                {"error": "New title is required"}, status=status.HTTP_400_BAD_REQUEST
-            )
+            return Response({"error": "New title is required"}, status=status.HTTP_400_BAD_REQUEST)
 
         conversation.title = new_title
         conversation.save()
 
-        return Response(
-            {"status": "Title updated successfully", "title": conversation.title}
-        )
+        return Response({"status": "Title updated successfully", "title": conversation.title})
 
     def get_chatgpt_response(self, conversation, user_message, page_context=None):
         client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
-        messages = [
-            {
-                "role": "system",
-                "content": "You are a knowledgeable assistant. Balancer is a powerful tool for selecting bipolar medication for patients. We are open-source and available for free use. Your primary role is to assist licensed clinical professionals with information related to Balancer and bipolar medication selection. If applicable, use the supplied tools to assist the professional.",
-            }
-        ]
+        messages = [{
+            "role": "system",
+            "content": "You are a knowledgeable assistant. Balancer is a powerful tool for selecting bipolar medication for patients. We are open-source and available for free use. Your primary role is to assist licensed clinical professionals with information related to Balancer and bipolar medication selection. If applicable, use the supplied tools to assist the professional."
+        }]
 
         if page_context:
             context_message = f"If applicable, please use the following content to ask questions. If not applicable, please answer to the best of your ability: {page_context}"
@@ -169,7 +157,7 @@ def get_chatgpt_response(self, conversation, user_message, page_context=None):
                 model="gpt-3.5-turbo",
                 messages=messages,
                 tools=tools,
-                tool_choice="auto",
+                tool_choice="auto"
             )
 
             response_message = response.choices[0].message
@@ -178,41 +166,37 @@ def get_chatgpt_response(self, conversation, user_message, page_context=None):
             tool_calls = response_message.model_dump().get("tool_calls", [])
 
             if not tool_calls:
-                return response_message["content"]
+                return response_message['content']
 
             # Handle tool calls
             # Add the assistant's message with tool calls to the conversation
-            messages.append(
-                {
-                    "role": "assistant",
-                    "content": response_message.content or "",
-                    "tool_calls": tool_calls,
-                }
-            )
+            messages.append({
+                "role": "assistant",
+                "content": response_message.content or "",
+                "tool_calls": tool_calls
+            })
 
             # Process each tool call
             for tool_call in tool_calls:
-                tool_call_id = tool_call["id"]
-                tool_function_name = tool_call["function"]["name"]
+                tool_call_id = tool_call['id']
+                tool_function_name = tool_call['function']['name']
                 tool_arguments = json.loads(
-                    tool_call["function"].get("arguments", "{}")
-                )
+                    tool_call['function'].get('arguments', '{}'))
 
                 # Execute the tool
                 results = execute_tool(tool_function_name, tool_arguments)
 
                 # Add the tool response message
-                messages.append(
-                    {
-                        "role": "tool",
-                        "content": str(results),  # Convert results to string
-                        "tool_call_id": tool_call_id,
-                    }
-                )
+                messages.append({
+                    "role": "tool",
+                    "content": str(results),  # Convert results to string
+                    "tool_call_id": tool_call_id
+                })
 
             # Final API call with tool results
             final_response = client.chat.completions.create(
-                model="gpt-3.5-turbo", messages=messages
+                model="gpt-3.5-turbo",
+                messages=messages
             )
             return final_response.choices[0].message.content
         except OpenAI.error.OpenAIError as e:
@@ -231,12 +215,9 @@ def generate_title(self, conversation):
         response = client.chat.completions.create(
             model="gpt-3.5-turbo",
             messages=[
-                {
-                    "role": "system",
-                    "content": "You are a helpful assistant that generates short, descriptive titles.",
-                },
-                {"role": "user", "content": prompt},
-            ],
+                {"role": "system", "content": "You are a helpful assistant that generates short, descriptive titles."},
+                {"role": "user", "content": prompt}
+            ]
         )
 
         return response.choices[0].message.content.strip()

server/api/views/text_extraction/urls.py

@@ -1,16 +1,11 @@
 from django.urls import path
-
 from .views import RuleExtractionAPIView, RuleExtractionAPIOpenAIView
 
+
 urlpatterns = [
-    path(
-        "v1/api/rule_extraction",
-        RuleExtractionAPIView.as_view(),
-        name="rule_extraction",
-    ),
-    path(
-        "v1/api/rule_extraction_openai",
-        RuleExtractionAPIOpenAIView.as_view(),
-        name="rule_extraction_openai",
-    ),
+
+    path('v1/api/rule_extraction', RuleExtractionAPIView.as_view(),
+         name='rule_extraction'),
+    path('v1/api/rule_extraction_openai', RuleExtractionAPIOpenAIView.as_view(),
+         name='rule_extraction_openai')
 ]