🧰 refactor/clean module, demos, docker-compose, and README.md

README.md

@@ -1,7 +1,7 @@
 # Gradio Flow 🤗
  
-**A web application with a backend in Flask and frontend in Rect, and React Flow that use [React flow](https://reactflow.dev/) node base environment to
-stream both gradio and streamlit interfaces, within a single application.**
+**A web application with a backend in Flask and frontend in Rect, and  [React flow](https://reactflow.dev/) node base environment to
+stream both [gradio](https://gradio.app) ( and later [streamlit](https://streamlit.io) ) interfaces, within a single application.**
  
  
 ## Tabel Of Contents 📚
@@ -78,7 +78,7 @@ Now that you're within the docker backend container environment you can start ad
 
 ```console
 > cd ./src
-> python index.py
+> python demoC.py
 //run example gradio application
 ```
 
@@ -110,7 +110,7 @@ It is quite simple, and similar within the docker build, the first way you can a
 **NOTE** If you use the gradio decorator compiler for gradio flow you need to set a listen port to 2000 or else the api will never get the key and will throw you an error, I'll also provided an example below if this isn't clear.
 
 ```python
-#backend/src/demo.py (functional base)
+#backend/src/demoF.py (functional base)
 ##########
 from resources import register, tabularGradio
 
@@ -118,33 +118,41 @@ from resources import register, tabularGradio
 def Hello_World(name):
         return f"Hello {name}, and welcome to Gradio Flow 🤗" 
 
-@register(["number", "number"], ["number"], examples=[[1,1]])
+@register(inputs=["number", "number"], outputs=["number"], examples=[[1,1]])
 def add(x, y):
     return x + y
 
 if __name__ == "__main__":
+    # run single gradio
     tabularGradio([Hello_World(), add()], ["Hello World", "Add"])
+
+    # run it within Gradio-Flow
+    # tabularGradio([Hello_World(), add()], ["Hello World", "Add"], listen=2000)
+    
 ```
 
 ```python
-#backend/src/index.py (Class Base)
+#backend/src/demoC.py (Class Base)
 ###########
 from resources import GradioModule, register
 
 @GradioModule
 class Greeting:
 
-    @register(["text"], ["text"])
+    @register(["text"], ["text"], examples=[["Luca Vivona"]])
     def Hello_World(self, name):
         return f"Hello {name}, and welcome to Gradio Flow 🤗" 
 
-    @register(["number", "number"], ["number"], examples=[[1,1]])
+    @register(inputs=["number", "number"], outputs=["number"], examples=[[1,1]])
     def add(self, x, y):
         return x + y
 
 
 if __name__ == "__main__":
-    Greeting().run(listen=2000)
+    # run just gradio
+    Greeting().launch()
+    # run it within Gradio-flow
+    # Greeting().launch(listen=2000)
 ```` 
 ## Application 🏛️
-![Application](https://github.com/commune-ai/Gradio-Flow/blob/gradio-flow/gradio-only/app.png)
+![Application](https://github.com/commune-ai/Gradio-Flow/blob/gradio-flow/gradio-only/app.png)

backend/src/__init__.py

@@ -1,4 +1,4 @@
 import examples
 import resource
-import src.demo 
-import src.index
+import src.demoF 
+import src.demoC

backend/src/{index.py → demoC.py}

@@ -3,7 +3,7 @@ from resources import GradioModule, register
 @GradioModule
 class Greeting:
 
-    @register(["text"], ["text"])
+    @register(["text"], ["text"], examples=[["Luca Vivona"]])
     def Hello_World(self, name):
         return f"Hello {name}, and welcome to Gradio Flow 🤗" 
 
@@ -11,5 +11,11 @@ class Greeting:
     def add(self, x, y):
         return x + y
 
+
 if __name__ == "__main__":
-    Greeting().run(listen=2000)
+    # run just gradio
+    Greeting().launch()
+    # run it within Gradio-flow
+    # Greeting().launch(listen=2000)
+
+    

backend/src/{demo.py → demoF.py}

@@ -10,4 +10,9 @@ def add(x, y):
     return x + y
 
 if __name__ == "__main__":
-    tabularGradio([Hello_World(), add()], ["Hello World", "Add"])
+    # run single gradio
+    tabularGradio([Hello_World(), add()], ["Hello World", "Add"])
+
+    # run it within Gradio-Flow
+    # tabularGradio([Hello_World(), add()], ["Hello World", "Add"], listen=2000)
+    

backend/src/resources/module.py

@@ -32,10 +32,15 @@ DOCKER_LOCAL_HOST = '0.0.0.0'
 DOCKER_PORT = Dock()
 
 def tabularGradio(funcs, names, name="Tabular Temp Name", **kwargs):
-    #print([fn.__name__ for fn in funcs])
-    assert len(funcs) == len(names), f"{bcolor.BOLD}{bcolor.FAIL}🐛 something went wrong!!! The function you appended dose not match the lenght of the names{bcolor.ENDC}"
-    # assert all([fn == "wrap" for fn in funcs]), f"{bcolor().BOLD}{bcolor().FAIL}not all of these are decorated with the right decorator{bcolor().ENDC}"
+    """
+    takes all gradio Interfaces, and names
+    from input and launch the gradio.
+    """
+
+    assert len(funcs) == len(names), f"{bcolor.BOLD}{bcolor.FAIL}🐛 something went wrong!!! The function you appended dose not match the length of the names{bcolor.ENDC}"
     port= kwargs["port"] if "port" in kwargs else DOCKER_PORT.determinePort()
+    
+    # send this to the backend api for it to be read by the react frontend
     if 'listen' in kwargs:
         try:
             requests.post(f"http://{DOCKER_LOCAL_HOST}:{ kwargs[ 'listen' ] }/api/append/port", json={"port" : port, "host" : f'http://localhost:{port}', "file" : 'Not Applicable', "name" : name, "kwargs" : kwargs})
@@ -43,6 +48,7 @@ def tabularGradio(funcs, names, name="Tabular Temp Name", **kwargs):
             print(f"**{bcolor.BOLD}{bcolor.FAIL}CONNECTION ERROR{bcolor.ENDC}** 🐛The listening api is either not up or you choose the wrong port.🐛 \n {e}")
             return
     
+    # provided by gradio a tabularInterface function that take function and names
     gr.TabbedInterface(funcs, names).launch(server_port=port,
                                             server_name=f"{DOCKER_LOCAL_HOST}",
                                             inline= kwargs['inline'] if "inline" in kwargs else True,
@@ -63,53 +69,74 @@ def tabularGradio(funcs, names, name="Tabular Temp Name", **kwargs):
                                             ssl_certfile=kwargs['ssl_certfile'] if "ssl_certfile" in kwargs else None,
                                             ssl_keyfile_password=kwargs['ssl_keyfile_password'] if "ssl_keyfile_password" in kwargs else None,
                                             quiet=kwargs['quiet'] if "quiet" in kwargs else False)
+    
+    # Ctrl+C that ends the process and then continue the code which will remove from the api
     if 'listen' in kwargs:
         try:
             requests.post(f"http://{DOCKER_LOCAL_HOST}:{ kwargs[ 'listen' ] }/api/remove/port", json={"port" : port, "host" : f'http://localhost:{port}', "file" : 'Not Applicable', "name" : name, "kwargs" : kwargs})
-        except Exception as e:
-        
+        except Exception as e:    
             print(f"**{bcolor.BOLD}{bcolor.FAIL}CONNECTION ERROR{bcolor.ENDC}** 🐛The api either lost connection or was turned off...🐛 \n {e}")
     
     return
 
-    
+
+
 def register(inputs, outputs, examples=None, **kwargs):
     def register_gradio(func):
-        def wrap(*args, **wargs):                    
-            fn_name = func.__name__ 
+        
 
-            if 'self' in func.__code__.co_varnames and func.__name__ in dir(args[0]):
-                
+        def decorator(*args, **wargs):                    
+            if type(outputs) is list:
+                assert len(outputs) >= 1, f"❌ {bcolor.BOLD}{bcolor.FAIL}you have no outputs 🤨... {str(type(outputs))} {bcolor.ENDC}"
+            
+            fn_name = func.__name__ 
+            if 'self' in func.__code__.co_varnames and func.__code__.co_varnames[0] == 'self' and fn_name in dir(args[0]):     
                 """
                 given the decorator is on a class then
                 initialize a registered_gradio_functons
                 if not already initialize.
                 """
-                assert len(inputs) == func.__code__.co_argcount - 1, f"❌ {bcolor.BOLD}{bcolor.FAIL}inputs should have the same length as arguments{bcolor.ENDC}"
+               
+                if type(inputs) is list:
+                    assert len(inputs) == func.__code__.co_argcount - 1, f"❌ {bcolor.BOLD}{bcolor.FAIL}inputs should have the same length as arguments{bcolor.ENDC}"
 
                 try:
                     self = args[0]
                     self.registered_gradio_functons
                 except AttributeError:
-                    print("✨Initializing Class Functions...✨\n")
                     self.registered_gradio_functons = dict()
                 
-                
-
                 if not fn_name in self.registered_gradio_functons:
-                    self.registered_gradio_functons[fn_name] = dict(inputs=inputs, outputs=outputs, examples=examples)
-                
+                    self.registered_gradio_functons[fn_name] = dict(inputs=inputs,
+                                                                    outputs=outputs, 
+                                                                    examples=examples,
+                                                                    cache_examples=kwargs['cache_examples'] if "cache_examples" in kwargs else None,
+                                                                    examples_per_page=kwargs['examples_per_page'] if "examples_per_page" in kwargs else 10,
+                                                                    interpretation=kwargs['interpretation'] if "interpretation" in kwargs else None,
+                                                                    num_shap=kwargs['num_shap'] if "num_shap" in kwargs else 2.0,
+                                                                    title=kwargs['title'] if "title" in kwargs else None,
+                                                                    article=kwargs['article'] if "article" in kwargs else None,
+                                                                    thumbnail=kwargs['thumbnail'] if "thumbnail" in kwargs else None,
+                                                                    css=kwargs['css'] if "css" in kwargs else None,
+                                                                    live=kwargs['live'] if "live" in kwargs else False,
+                                                                    allow_flagging=kwargs['allow_flagging'] if "allow_flagging" in kwargs else None,
+                                                                    theme=kwargs['theme'] if "theme" in kwargs else  'default', )
+
                 if len(args[1:]) == (func.__code__.co_argcount - 1):
                     return func(*args, **wargs) 
+                return None
             else :
                 """
                 the function is not a class function
                 """
-                assert len(inputs) == func.__code__.co_argcount, f"❌ {bcolor.BOLD}{bcolor.FAIL}inputs should have the same length as arguments{bcolor.ENDC}"
+                if type(inputs) is list:    
+                    assert len(inputs) == func.__code__.co_argcount, f"❌ {bcolor.BOLD}{bcolor.FAIL}inputs should have the same length as arguments{bcolor.ENDC}"
 
+                # if the arguments within the functions are inputed then just return the output
                 if len(args) == (func.__code__.co_argcount):
                     return func(*args, **wargs)
 
+                # if there is nothing in the arugumrnt then return the gradio interface
                 return gr.Interface(fn=func,
                                     inputs=inputs,
                                     outputs=outputs,
@@ -126,82 +153,60 @@ def register(inputs, outputs, examples=None, **kwargs):
                                     allow_flagging=kwargs['allow_flagging'] if "allow_flagging" in kwargs else None,
                                     theme='default', 
                                     )
-
-                return None
-        return wrap
+        return decorator
     return register_gradio
 
 def GradioModule(cls):
     class Decorator:
 
         def __init__(self) -> None:
-            self.cls = cls()
-
-        def get_funcs(self):
-            return [func for func in dir(self.cls) if not func.startswith("__") and type(getattr(self.cls, func, None)) == type(self.get_funcs) ]
-
-        def compile(self, **kwargs):
-            print("Just putting on the finishing touches... 🔧🧰")
-            for func in self.get_funcs():
-                this = getattr(self.cls, func, None)
-                if this.__name__ == "wrap":
-                    this()
+            self.__cls__ = cls()
+            self.__get_funcs_attr()
+            self.interface = self.__compile()
+        
+        def get_funcs_names(self):
+            assert self.get_registered_map() != None, "this is not possible..."
+            return [ name for name in self.get_registered_map().keys()]
 
+        def get_registered_map(self):
+            assert self.__cls__.registered_gradio_functons != None, "what happen!!!!"
+            return self.__cls__.registered_gradio_functons
+        
+        def __get_funcs_attr(self):
+            for func in dir(self.__cls__):
+                fn = getattr(self.__cls__, func, None)
+                if not func.startswith("__") and fn.__name__ == "decorator":
+                    fn()
+
+        def __compile(self):
+            """
+            Initialize all the function 
+            within the class that are registeed
+            """
             demos, names = [], []
-            for func, param in self.get_registered_gradio_functons().items():                
+            for func, param in self.get_registered_map().items():                
                 names.append(func)
-                demos.append(gr.Interface(fn=getattr(self.cls, func, None),
-                                            inputs=param['inputs'],
-                                            outputs=param['outputs'],
-                                            examples=param['examples'],
-                                            cache_examples=kwargs['cache_examples'] if "cache_examples" in kwargs else None,
-                                            examples_per_page=kwargs['cache_examples'] if "cache_examples" in kwargs else 10,
-                                            interpretation=kwargs['interpretation'] if "interpretation" in kwargs else None,
-                                            num_shap=kwargs['num_shap'] if "num_shap" in kwargs else 2.0,
-                                            title=kwargs['title'] if "title" in kwargs else None,
-                                            article=kwargs['article'] if "article" in kwargs else None,
-                                            thumbnail=kwargs['thumbnail'] if "thumbnail" in kwargs else None,
-                                            css=kwargs['css'] if "css" in kwargs else None,
-                                            live=kwargs['live'] if "live" in kwargs else False,
-                                            allow_flagging=kwargs['allow_flagging'] if "allow_flagging" in kwargs else None,
-                                            theme='default', 
-                                            ))
-                print(f"{func}....{bcolor.BOLD}{bcolor.OKGREEN} done {bcolor.ENDC}")
-
-            print("\nHappy Visualizing... 🚀")
+                try:
+                    demos.append(gr.Interface(fn=getattr(self.__cls__, func, None), **param))
+                except Exception as e :
+                    raise e
+
+            print(f"{bcolor.OKBLUE}COMPLETED: {bcolor.ENDC}All functions are mapped, and ready to launch 🚀",
+                 "\n===========================================================\n")
             return gr.TabbedInterface(demos, names)
             
-        def get_registered_gradio_functons(self):
-            try:
-                self.cls.registered_gradio_functons
-            except AttributeError:
-                return None
-            return self.cls.registered_gradio_functons
-        
-
-        def run(self, **kwargs):
+        def launch(self, **kwargs):
             port= kwargs["port"] if "port" in kwargs else DOCKER_PORT.determinePort() 
             if 'listen' in kwargs:
                 try:
-                    requests.post(f"http://{DOCKER_LOCAL_HOST}:{ kwargs[ 'listen' ] }/api/append/port", json={"port" : port, "host" : f'http://localhost:{port}', "file" : getfile(self.cls.__class__), "name" : self.cls.__class__.__name__, "kwargs" : kwargs})
+                    requests.post(f"http://{DOCKER_LOCAL_HOST}:{ kwargs[ 'listen' ] }/api/append/port", json={"port" : port, "host" : f'http://localhost:{port}', "file" : getfile(self.__cls__.__class__), "name" : self.__cls__.__class__.__name__, "kwargs" : kwargs})
                 except Exception:
                     print(f"**{bcolor.BOLD}{bcolor.FAIL}CONNECTION ERROR{bcolor.ENDC}** 🐛The listening api is either not up or you choose the wrong port.🐛")
                     return
 
-            self.compile(live=kwargs[ 'live' ] if "live" in kwargs else False,
-                         allow_flagging=kwargs[ 'allow_flagging' ] if "allow_flagging" in kwargs else None,
-                         cache_examples=kwargs['cache_examples'] if "cache_examples" in kwargs else None,
-                         examples_per_page=kwargs['cache_examples'] if "cache_examples" in kwargs else 10,
-                         interpretation=kwargs['interpretation'] if "interpretation" in kwargs else None,
-                         num_shap=kwargs['num_shap'] if "num_shap" in kwargs else 2.0,
-                         title=kwargs['title'] if "title" in kwargs else None,
-                         article=kwargs['article'] if "article" in kwargs else None,
-                         thumbnail=kwargs['thumbnail'] if "thumbnail" in kwargs else None,
-                         css=kwargs['css'] if "css" in kwargs else None,
-                         theme=kwargs['theme'] if "theme" in kwargs else None, 
-                         ).launch(server_port=port,
+            self.interface.launch(server_port=port,
                                   server_name=f"{DOCKER_LOCAL_HOST}",
-                                  inline= kwargs['inline'] if "inline" in kwargs else True,
+                                  inline= kwargs['inline'] if "inline" in kwargs else None,
                                   share=kwargs['share'] if "share" in kwargs else None,
                                   debug=kwargs['debug'] if "debug" in kwargs else False,
                                   enable_queue=kwargs['enable_queue'] if "enable_queue" in kwargs else None,
@@ -221,15 +226,13 @@ def GradioModule(cls):
                                   quiet=kwargs['quiet'] if "quiet" in kwargs else False) 
             if 'listen' in kwargs:
                 try:
-                    requests.post(f"http://{DOCKER_LOCAL_HOST}:{ kwargs[ 'listen' ] }/api/remove/port", json={"port" : port, "host" : f'http://localhost:{port}', "file" : getfile(self.cls.__class__), "name" : self.cls.__class__.__name__, "kwargs" : kwargs})
+                    requests.post(f"http://{DOCKER_LOCAL_HOST}:{ kwargs[ 'listen' ] }/api/remove/port", json={"port" : port, "host" : f'http://localhost:{port}', "file" : getfile(self.__cls__.__class__), "name" : self.__cls__.__class__.__name__, "kwargs" : kwargs})
                 except Exception:
                     print(f"**{bcolor.BOLD}{bcolor.FAIL}CONNECTION ERROR{bcolor.ENDC}** 🐛The api either lost connection or was turned off...🐛")
             return
 
     return Decorator
 
-
-
 class bcolor:
     HEADER = '\033[95m'
     OKBLUE = '\033[94m'

backend/test/test.py

@@ -21,19 +21,48 @@ def Hello(name):
 def Goodbye(name):
     return f"Goodbye, {name}."
 
+@register(['number', 'number'], ['number'], examples=[[9, 10]])
+def add(x=0, y=0):
+    return x + y
+
+@register(['number'], ['number'], examples=[[9, 10]])
+def error_param(x=0, y=0):
+    return x + y
+
+@register(['number', "number"], [], examples=[[9, 10]])
+def error_no_output(x=0, y=0):
+    return x + y
+
+@register(['number', "number"], "number", examples=[[9, 10]])
+def foo(x=0, y=0):
+    return x + y
+
+
+
+
 class GradioFlowTestCase(unittest.TestCase):
-    cls = test()
+    hodl = test()
     def test_class_func_return(self):
-        self.assertEqual(self.cls.cls.Hello("Luca"), "Hello, Luca.")
-        self.assertEqual(self.cls.cls.Goodbye("Luca"), "Goodbye, Luca.")
+        self.assertEqual(self.hodl.__cls__.Hello("Luca"), "Hello, Luca.")
+        self.assertEqual(self.hodl.__cls__.Goodbye("Luca"), "Goodbye, Luca.")
 
+    def test_func_default_return(self):
+        self.assertEqual(add(1,1), 2)
 
     def test_func_return(self):
         self.assertEqual(Hello("Luca"), "Hello, Luca.")
         self.assertEqual(Goodbye("Luca"), "Goodbye, Luca.")
-  
-    
 
-        
+    def test_foo(self):
+        self.assertEqual(foo(1,1),2)
+
+    def test_functions_error_catch(self):
+        with self.assertRaises(AssertionError):
+            error_param()
+    
+    def test_function_error_no_output(self):
+        with self.assertRaises(AssertionError):
+            error_no_output()
+  
 
 unittest.main()

docker-compose.yml

@@ -11,6 +11,7 @@ services:
     ports:
       - "2000:2000"
       - "7860-7880:7860-7880"
+      # - "8501:8501" # streamlit application test
     command: "python app.py -p 2000"
   frontend :
     container_name: frontend