Merge pull request #10 from east-and-west-magic/feature-cache-query

app.py

@@ -8,13 +8,14 @@ import gradio as gr
 from gradio_client import Client
 from extract import extract
 import app_util
+import cache
 from pgsoft.pgconst.const import service_list, functionality_list, game_list
 from pgsoft.pgdate.date_utils import beijing
 
 #######################
 # proxy version
 #######################
-proxy_version = "1.0.0-2023-12-01-a"  # use pgconst
+proxy_version = "1.0.0-2023-12-12-a"  # use cache
 
 t = datetime.now()
 t = t.astimezone(ZoneInfo("Asia/Shanghai"))
@@ -37,6 +38,8 @@ if not identity:
 space = "stevez-ai"
 if identity in spaces:
     space = spaces[identity]
+filepath = os.sep.join(["cache", "cached_ai.json"])
+cache.load_cache(filepath)
 
 
 def run(hf_token, service, game, functionality, nlp_command):
@@ -92,24 +95,27 @@ def run(hf_token, service, game, functionality, nlp_command):
             assert "games" in service_list
             if service == "games":
                 print(f"{beijing()} [{user_name}] [{game}] {nlp_command}")
-            client = Client(
-                url,
-                hf_token=token,
-                verbose=False,
-            )
-            calling_start = beijing()
-            print(f"calling ai starts at {calling_start}")
-            res = client.predict(
-                service,
-                game,
-                functionality,
-                nlp_command,  # hidden,
-                api_name="/predict",
-            )
-            calling_end = beijing()
-            timecost = calling_end.timestamp() - calling_start.timestamp()
-            print(f"calling ai ends at {calling_end}, costs {timecost:.2f}s")
-            outp = json.loads(res)
+            outp = cache.get_cache(nlp_command)
+            if outp is None:
+                client = Client(
+                    url,
+                    hf_token=token,
+                    verbose=False,
+                )
+                calling_start = beijing()
+                print(f"calling ai starts at {calling_start}")
+                res = client.predict(
+                    service,
+                    game,
+                    functionality,
+                    nlp_command,  # hidden,
+                    api_name="/predict",
+                )
+                calling_end = beijing()
+                timecost = calling_end.timestamp() - calling_start.timestamp()
+                print(f"calling ai ends at {calling_end}, costs {timecost:.2f}s")
+                outp = json.loads(res)
+                cache.add_cache(nlp_command, outp)
             # add proxy version info to the output
             outp["proxy-version"] = proxy_version
             outp["user"] = user_name

cache.py

@@ -0,0 +1,39 @@
+import os
+import json
+from pgsoft.pgdate.date_utils import beijing
+
+cache_ai = {}
+
+
+def normalize_text(text: str) -> str:
+    text = text.lower()
+    tmp = text.split(" ")
+    tmp = [word for word in tmp if word != ""]
+    return " ".join(tmp)
+
+
+def load_cache(filepath: str):
+    """load cached ai calling from a json file"""
+    global cache_ai
+    if os.path.exists(filepath):
+        with open(filepath, "r+") as f:
+            cache_ai = json.load(f)
+
+
+def add_cache(command: str, result: dict):
+    """add a cache of ai calling"""
+    command = normalize_text(command)
+    result["command"] = command
+
+    global cache_ai
+    cache_ai[command] = result
+    print(f'[cache] added "{command}"')
+
+
+def get_cache(command: str) -> dict | None:
+    """return a cached ai calling with new "timestamp" """
+    command = normalize_text(command)
+    outp = cache_ai.get(command)
+    if outp:
+        outp["timestamp"] = beijing().__str__()
+    return outp