use call_ai

app.py

@@ -1,21 +1,19 @@
-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
+from call_ai import call_ai
 
 #######################
 # 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 +21,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 +34,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):
@@ -91,51 +85,27 @@ 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}")
+        outp = 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
+        app_util.call_logger(outp, identity, token)
     service_end = beijing()
     timecost = service_end.timestamp() - service_start.timestamp()
     print(