feat: workflow

src/blackbox/audio_to_text.py

@@ -39,7 +39,7 @@ class AudioToText(Blackbox):
             return JSONResponse(content={"error": "data is required"}, status_code=status.HTTP_400_BAD_REQUEST)
         d = await data.read()
         try:
-            txt = await self.processing(d)
+            txt = self.processing(d)
         except ValueError as e:
             return JSONResponse(content={"error": str(e)}, status_code=status.HTTP_400_BAD_REQUEST)
-        return JSONResponse(content={"txt": txt}, status_code=status.HTTP_200_OK)
+        return JSONResponse(content={"text": txt}, status_code=status.HTTP_200_OK)

src/blackbox/blackbox_factory.py

@@ -112,12 +112,24 @@ def sum_loader():
     from .sum  import Sum
     return Injector().get(Sum)
 
+@model_loader(lazy=blackboxConf.lazyloading)
+def audio_to_text_loader():
+    from .audio_to_text  import AudioToText
+    return Injector().get(AudioToText)
+
+@model_loader(lazy=blackboxConf.lazyloading)
+def text_to_audio_loader():
+    from .text_to_audio  import TextToAudio
+    return Injector().get(TextToAudio)
+
 @singleton
 class BlackboxFactory:
     models = {}
 
     @inject
     def __init__(self,) -> None:
+        self.models["text_to_audio"] = text_to_audio_loader
+        self.models["audio_to_text"] = audio_to_text_loader
         self.models["asr"] = asr_loader
         self.models["tts"] = tts_loader
         self.models["sentiment_engine"] = sentiment_loader

src/blackbox/text_to_audio.py

@@ -4,6 +4,7 @@ from .blackbox import Blackbox
 from gtts import gTTS
 from io import BytesIO
 from injector import singleton
+
 @singleton
 class TextToAudio(Blackbox):
     

src/blackbox/workflow.py

@@ -1,36 +1,30 @@
 
+from .audio_to_text import AudioToText
+from .text_to_audio import TextToAudio
 from .sum import Sum
-from fastapi import Request
+from fastapi import Request, Response
 from .blackbox import Blackbox
 from injector import singleton, inject
 from ..dotchain.runtime.interpreter import program_parser
 from ..dotchain.runtime.runtime import Runtime
 from ..dotchain.runtime.tokenizer import Tokenizer
 from ..dotchain.runtime.ast import Literal
+import json
 
-@singleton
+def read_binay(io):
-class Workflow(Blackbox):
+    return Literal(io.read())
 
-    @inject
+def new_map():
-    def __init__(self, sum: Sum):
+    return Literal({})
-        self.sum_blackbox = sum
 
-    def __call__(self, *args, **kwargs):
+def set_map(map: dict, key, value):
-        return self.processing(*args, **kwargs)
+    map[key] = value 
+    return map
 
-    def sum(self, *args, **kwargs):
+def jsonfiy(obj):
-        return Literal(self.sum_blackbox.processing(*args, **kwargs))
+    return Literal(json.dumps(obj))
 
-    async def processing(self, *args, **kwargs):
+def get_value(d: dict, key):
-        request = args[0]
-        json = await request.json()
-        result = None
-        
-        def set_result(r):
-            nonlocal result
-            result = r
-        
-        def get_value(d: dict, key):
     value = d.get(key)
     if value is dict:
         return value
@@ -38,24 +32,79 @@ class Workflow(Blackbox):
         return value
     return Literal(value)
 
+@singleton
+class Workflow(Blackbox):
+    
+    @inject
+    def __init__(self, sum: Sum, 
+                 audio_to_text: AudioToText,
+                 text_to_audio: TextToAudio) -> None:
+        self.sum_blackbox = sum
+        self.audio_to_text = audio_to_text
+        self.text_to_audio_blackbox = text_to_audio
+    
+    def __call__(self, *args, **kwargs):
+        return self.processing(*args, **kwargs)
+    
+    def text_to_audio(self, text):
+        return Literal(self.text_to_audio_blackbox.processing(text))
+    
+    def sum(self, *args, **kwargs):
+        return Literal(self.sum_blackbox.processing(*args, **kwargs))
+    
+    async def processing(self, *args, **kwargs):
+        request = args[0]
+        json = await request.json()
+        content = None
+        mdeia_type = None
+        headers = {}
+        def set_content(c):
+            nonlocal content
+            content = c
+        def set_media_type(m):
+            nonlocal mdeia_type
+            mdeia_type = m
+        def add_header(key, value):
+            nonlocal headers
+            headers[key] = value
+        
         script = json["script"]
         t = Tokenizer()
         t.init(script)
         runtime = Runtime(
             context={"json": json},
             exteral_fun={
+                "new_map": new_map,
+                "set_map": set_map,
+                "audio_to_text": self.audio_to_text,
+                "text_to_audio": self.text_to_audio,
                 "get_value": get_value,
                 "print": print, 
-                "set_result": set_result,
+                "set_content": set_content,
+                "set_media_type": set_media_type,
+                "add_header": add_header,
                 "sum": self.sum,
+                "read_binay": read_binay,
+                "jsonfiy": jsonfiy,
             }
         )
         ast = program_parser(t)
         ast.exec(runtime)
-        return result
+        return Response(content=content, media_type=mdeia_type, headers=headers)
     
     def valid(self, *args, **kwargs) -> bool:
         return super().valid(*args, **kwargs)
     
     async def fast_api_handler(self, request: Request):
         return await self.processing(request)
+        # return Response(content=b.read(), media_type="audio/mp3", headers={"Content-Disposition": "attachment; filename=audio.mp3"})
+    
+"""
+let b = new_map();
+set_map(b,"man","good");
+let a = new_map();
+set_map(a, "hello", "world");
+set_map(a, "hello2", b);
+set_media_type("application/json");
+set_content(jsonfiy(a));
+"""