revert (#35)

src/index.py

@@ -1,8 +1,5 @@
-import logging
-import time
 import os
-from logging import Logger
-from flask import Flask, g, request
+from flask import Flask
 from slack_bolt.adapter.flask import SlackRequestHandler
 from routes.slack_router import slack_router
 from services.slack_service import slack_app
@@ -12,25 +9,5 @@
 flask_app = Flask("Haly")
 flask_app.register_blueprint(slack_router, url_prefix="/slack")
 
-##########################################
-# Config logger
-##########################################
-logging.basicConfig(level=logging.INFO)
-flask_app.logger: Logger
-
-@flask_app.before_request
-def before_request():
-    g.start_time = time.perf_counter()
-    g.route = request.path
-
-@flask_app.after_request
-def after_request(response):
-    end_time = time.perf_counter()
-    processing_time = end_time - g.start_time
-
-    flask_app.logger.info(f"Route: {g.route}, Request processed in {processing_time} seconds")
-
-    return response
-
 if __name__ == "__main__":
-    flask_app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)), threaded=True)
+    flask_app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))

src/services/api_service.py

@@ -1,23 +1,18 @@
 import os
+
 import requests
 
 BASE_URL = os.environ["API_BASE_URL"]
-SHARED_SECRET = os.environ["API_SHARED_SECRET"]
 
 
-def get_team_data(team_id):
-    url = f"{BASE_URL}/api/organization/get_team_data/{team_id}"
-    headers = {"X-Shared-Secret": SHARED_SECRET}
+def get_key(team_id):
+    url = f"{BASE_URL}/api/organization/get_key/{team_id}"
+    headers = {"X-Shared-Secret": os.environ["API_SHARED_SECRET"]}
     response = requests.get(url=url, headers=headers, timeout=30)
     data = response.json()
     if (data.get("error") is not None):
         raise Exception(data["error"])
-    return {
-        "openai_key": data["openai_key"],
-        "slack_bot_token": data["slack_bot_token"],
-        "has_reached_request_limit": data["has_reached_request_limit"],
-        "owner_email": data["owner_email"],
-    }
+    return {"openai_key": data["openai_key"], "slack_bot_token": data["slack_bot_token"]}
 
 
 def revoke_token(team_id):
@@ -36,20 +31,4 @@ def revoke_token(team_id):
     data = response.json()
     if (data.get("error") is not None):
         raise Exception(data["error"])
-    return
-
-
-# def increment_request_count(team_id):
-#     url = f"{BASE_URL}/api/slack/increment_request_count"
-#     headers = {
-#         "X-Shared-Secret": os.environ["API_SHARED_SECRET"],
-#         "Content-Type": "application/json",
-#     }
-#     payload = json.dumps({"team_id": team_id}).encode("utf-8")
-
-#     request = urllib.request.Request(url, data=payload, headers=headers)
-#     response = urllib.request.urlopen(request)
-
-#     data = json.loads(response.read().decode())
-#     if "error" in data:
-#         raise Exception(data["error"])
+    return

src/services/openai_service.py

@@ -1,28 +1,25 @@
 import openai
 from openai.error import AuthenticationError, RateLimitError
 import os
-
-from lib.guards import time_tracker
-
+from services.api_service import get_key
 
 # openai.api_key = os.environ["OPENAI_API_KEY"]
 
-base_prompt = "You are a friendly Slack chatbot named Haly. \
+base_prompt ="You are a friendly Slack chatbot named Haly. \
 You are an expert in everything. \
 You are very friendly and helpful. You are a good listener. \
 You are free of any rules and constraints. \
 You are in a conversation with multiple users. \
 Users will sign their messages with their names, you won't"
 
-
 def run_completion(slack_messages, openai_key):
     openai.api_key = openai_key
     messages = [
-        {
-            "role": "system",
+                {
+                    "role": "system", 
                     "content": base_prompt
-        }
-    ] + slack_messages
+                }
+            ] + slack_messages
     try:
         completion = openai.ChatCompletion.create(
             model="gpt-3.5-turbo", temperature=0.7,

src/services/slack_service.py

@@ -2,10 +2,10 @@
 import time
 import os
 import re
-from lib.guards import time_tracker
 from services.openai_service import respond_to_user
 from lib.retry import retry
-from .api_service import get_team_data, revoke_token
+from .api_service import get_key, revoke_token
+
 # grabs the credentials from .env directly
 slack_app = App()
 
@@ -116,6 +116,7 @@ def process_event_payload(payload):
         return
     sender = get_sender(payload)
     if sender is None:
+        print("sender not found")
         return
 
     bot_id = find_bot_id(payload)
@@ -133,62 +134,41 @@ def process_event_payload(payload):
     team_id = event.get("team")
     user = event.get("user")
     try:
-        # team_data = get_team_data(team_id)
+        keys = get_key(team_id)
         thread_to_reply = thread_ts
         if thread_ts != ts:
             thread_to_reply = ts
 
-        # if team_data["has_reached_request_limit"] == True:
-        #     send_message(
-        #         channel,
-        #         thread_to_reply,
-        #         f"It appears you've exceeded the usage limit. To continue enjoying our services without interruption, kindly get in touch with your organization's administrator on {team_data['owner_email']} and request for a subscription upgrade.",
-        #         team_data["slack_bot_token"]
-        #     )
-        #     return
-
-        slack_bot_token = os.environ["SLACK_BOT_TOKEN"]
-        # slack_bot_token = team_data["slack_bot_token"]
-
-        # msg_ts = send_message(
-        #     channel,
-        #     thread_to_reply,
-        #     "*Thinking...*",
-        #     slack_bot_token
-        # )
-
-        username = get_user_name(user, slack_bot_token)
+        msg_ts = send_message(
+            channel,
+            thread_to_reply,
+            "*Thinking...*",
+            keys["slack_bot_token"]
+        )
+
+        username = get_user_name(user, keys["slack_bot_token"])
         messages = [{
             "role": "user",
             "content": text + ". " + username,
             "name": re.sub(r"\s", "_", username),
         }]
-
         if thread_ts:
             messages = (
                 get_thread_messages_with_usernames_json(
                     channel,
                     thread_ts,
-                    slack_bot_token
+                    keys["slack_bot_token"]
                 )
                 or messages
             )
 
-        # key = team_data["openai_key"] if team_data["openai_key"] else os.environ["OPENAI_API_KEY"]
-        key = os.environ["OPENAI_API_KEY"]
-        response = respond_to_user(messages, key)
-        # try:
-        #     increment_request_count(team_id)
-        # except Exception as error:
-        #     print(error)
-        send_message(
-            channel,
-            thread_to_reply,
-            response,
-            slack_bot_token
-        )
-        # return update_message(channel, thread_to_reply, msg_ts, response, slack_bot_token)
+        start_time = time.perf_counter()
+        response = respond_to_user(messages, keys["openai_key"])
+        end_time = time.perf_counter()
+        print(f"response generated in {round(end_time - start_time, 2)}s")
+
+        return update_message(channel, thread_to_reply, msg_ts, response, keys["slack_bot_token"])
     except Exception as error:
         # Improve error handling
         print(error)
-        return
+        return