Merge pull request #12 from east-and-west-magic/feature-call-ai

app.py

@@ -1,21 +1,20 @@
-import requests
 import json
 import os
 from datetime import datetime
 from zoneinfo import ZoneInfo
 
 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
+import call_ai
+from str_util import normalize_text
 
 #######################
 # proxy version
 #######################
-proxy_version = "1.0.0-2023-12-12-a"  # use cache
+proxy_version = "1.0.0-2023-12-13-a"  # reconstruct ai calling
 
 t = datetime.now()
 t = t.astimezone(ZoneInfo("Asia/Shanghai"))
@@ -23,8 +22,6 @@ print(f"[Beijing]: {t.replace(microsecond=0)}")
 t = t.astimezone(ZoneInfo("America/Los_Angeles"))
 print(f"[Seattle]: {t.replace(microsecond=0)}")
 
-# assert False
-
 
 spaces = {
     "b_demo_hf": "stevez-ai",
@@ -38,8 +35,6 @@ 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):
@@ -58,6 +53,7 @@ def run(hf_token, service, game, functionality, nlp_command):
         space = redirect
     url = f"https://{space}.hf.space"
 
+    nlp_command = normalize_text(nlp_command)
     if token is None or token == "":
         return "please specify hf token"
 
@@ -91,51 +87,29 @@ def run(hf_token, service, game, functionality, nlp_command):
         else:
             outp = {"status": "OK", "result": json.loads(res)["result"]}
     else:
-        try:
-            assert "games" in service_list
-            if service == "games":
-                print(f"{beijing()} [{user_name}] [{game}] {nlp_command}")
-            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)
-                outp["cache"] = False
-                cache.add_cache(nlp_command, outp)
-            else:
-                print(f"[cache] return from cache")
-            # add proxy version info to the output
-            outp["proxy-version"] = proxy_version
-            outp["user"] = user_name
-            outp["game"] = game
-            if source:
-                outp["source"] = source
-            calling_start = beijing()
-            print(f"calling logger starts at {beijing()}")
-            app_util.call_logger(outp, identity, token)
-            calling_end = beijing()
-            timecost = calling_end.timestamp() - calling_start.timestamp()
-            print(f"calling logger ends at {calling_end}, costs {timecost:.2f}s")
-        except Exception as e:
-            return (
-                f"{type(e)}, {str(e)}. \nyou may want to make "
-                + "sure your hf_token is correct"
-            )
+        assert "games" in service_list
+        if service == "games":
+            print(f"{beijing()} [{user_name}] [{game}] {nlp_command}")
+        call_ai.from_cache = True
+        outp = call_ai.call_ai(
+            service,
+            game,
+            functionality,
+            nlp_command,
+            url,
+            token,
+        )
+        if isinstance(outp, str):
+            return outp
+        # add proxy version info to the output
+        outp["timestamp"] = beijing().__str__()
+        outp["proxy-version"] = proxy_version
+        outp["user"] = user_name
+        outp["game"] = game
+        if source:
+            outp["source"] = source
+        outp["cache"] = call_ai.from_cache
+        app_util.call_logger(outp, identity, token)
     service_end = beijing()
     timecost = service_end.timestamp() - service_start.timestamp()
     print(

app_util.py

@@ -1,17 +1,20 @@
 import json
 
 from gradio_client import Client
+from pgsoft.pgdate.date_utils import beijing
 
 
 def call_logger(log_info, caller, hf_token) -> None:
     #######################
     # logging
     #######################
+    calling_start = beijing()
+    print(f"calling logger starts at {beijing()}")
+    #################################################
     urls = [
         "https://hubei-hunan-logger.hf.space",
         "https://hubei-hunan-logger2.hf.space",
     ]
-
     for url in urls:
         try:
             client = Client(
@@ -23,6 +26,10 @@ def call_logger(log_info, caller, hf_token) -> None:
             print(f"[logging to {url}] OK")
         except Exception as e:
             print(f"[logging to {url}] error: {e}")
+    #################################################
+    calling_end = beijing()
+    timecost = calling_end.timestamp() - calling_start.timestamp()
+    print(f"calling logger ends at {calling_end}, costs {timecost:.2f}s")
 
 
 def call_clouddisk(service, arg, hf_token) -> str | None:

cache.py

@@ -1,40 +0,0 @@
-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__()
-        outp["cache"] = True
-    return outp

call_ai.py

@@ -0,0 +1,37 @@
+from functools import cache
+from gradio_client import Client
+from pgsoft.pgdate.date_utils import beijing
+import json
+
+from_cache = True
+
+
+@cache
+def call_ai(service, game, functionality, nlp_command, url, hf_token):
+    calling_start = beijing()
+    print(f"calling ai starts at {calling_start}")
+    try:
+        client = Client(
+            url,
+            hf_token=hf_token,
+            verbose=False,
+        )
+        res = client.predict(
+            service,
+            game,
+            functionality,
+            nlp_command,  # hidden,
+            api_name="/predict",
+        )
+    except Exception as e:
+        return (
+            f"{type(e)}, {str(e)}. \nyou may want to make "
+            + "sure your hf_token is correct"
+        )
+    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)
+    global from_cache
+    from_cache = False
+    return outp

str_util.py

@@ -0,0 +1,5 @@
+def normalize_text(text: str) -> str:
+    text = text.lower()
+    tmp = text.split(" ")
+    tmp = [word for word in tmp if word != ""]
+    return " ".join(tmp)