update viper

.gitignore

@@ -0,0 +1,21 @@
+# Ignore node modules
+node_modules/
+
+# Ignore log files
+logs
+*.log
+npm-debug.log*
+
+# Ignore Next.js build output
+.next
+
+# Ignore yarn error log
+yarn-error.log
+
+# Ignore IDE settings
+.vscode/
+
+# Ignore operating system files
+.DS_Store
+Thumbs.db
+ehthumbs.db

app.py

@@ -1,7 +1,30 @@
-import gradio as gr
+import logging
+from channels.channel import Channel
+from entities.entity import Entity
+from interactors.interactor import Interactor
+from presenters.presenter import Presenter
+from routers.router import Router
+from views.view import View
 
-def greet(name):
-    return "Hello " + name + "!!"
+def initialize_app():
+    # Tạo các thành phần
+    channel = Channel()
+    entity = Entity()
+    interactor = Interactor(channel, entity)
+    presenter = Presenter(channel)
+    router = Router(channel)
+    view = View(channel)
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+    # Xử lý các sự kiện từ người dùng
+    presenter.handle('render')
+    presenter.handle('create', 'sampleKey', 'sampleValue')
+    presenter.handle('read', 'sampleKey')
+    presenter.handle('update', 'sampleKey', 'updatedValue')
+    presenter.handle('delete', 'sampleKey')
+
+    # Điều hướng
+    router.navigate('Home')
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    initialize_app()

channels/channel.py

@@ -0,0 +1,38 @@
+import logging
+
+class Event:
+    def __init__(self):
+        self.listeners = {}
+
+    def on(self, event: str, listener: callable):
+        if event not in self.listeners:
+            self.listeners[event] = []
+        self.listeners[event].append(listener)
+        logging.info(f"Registered listener for event: {event}")
+
+    def off(self, event: str, listener: callable):
+        if event in self.listeners:
+            self.listeners[event] = [l for l in self.listeners[event] if l != listener]
+            logging.info(f"Unregistered listener for event: {event}")
+
+    def emit(self, event: str, *args, **kwargs):
+        if event in self.listeners:
+            for listener in self.listeners[event]:
+                try:
+                    listener(*args, **kwargs)
+                    logging.info(f"Emitted event: {event}")
+                except Exception as e:
+                    logging.error(f"Error emitting event {event}: {e}")
+
+class Channel:
+    def __init__(self):
+        self.event = Event()
+
+    def on(self, event: str, listener: callable):
+        self.event.on(event, listener)
+
+    def off(self, event: str, listener: callable):
+        self.event.off(event, listener)
+
+    def emit(self, event: str, *args, **kwargs):
+        self.event.emit(event, *args, **kwargs)

entities/entity.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+import logging
+
+@dataclass
+class Entity:
+    data: dict = {}
+
+    def create(self, key: str, value: any):
+        if not isinstance(key, str) or value is None:
+            logging.error('Invalid key or value')
+            return
+        self.data[key] = value
+        logging.info(f"Create: {key} = {value}")
+
+    def read(self, key: str):
+        if not isinstance(key, str):
+            logging.error('Invalid key')
+            return
+        value = self.data.get(key)
+        logging.info(f"Read: {key} = {value}")
+        return value
+
+    def update(self, key: str, value: any):
+        if not isinstance(key, str) or value is None:
+            logging.error('Invalid key or value')
+            return
+        self.data[key] = value
+        logging.info(f"Update: {key} = {value}")
+
+    def delete(self, key: str):
+        if not isinstance(key, str):
+            logging.error('Invalid key')
+            return
+        if key in self.data:
+            del self.data[key]
+            logging.info(f"Delete: {key}")

interactors/interactor.py

@@ -0,0 +1,40 @@
+import logging
+from channels.channel import Channel
+from entities.entity import Entity
+
+class Interactor:
+    def __init__(self, channel: Channel, entity: Entity):
+        self.channel = channel
+        self.entity = entity
+        self.channel.on('create', self.create)
+        self.channel.on('read', self.read)
+        self.channel.on('update', self.update)
+        self.channel.on('delete', self.delete)
+
+    def create(self, key: str, value: any):
+        try:
+            self.entity.create(key, value)
+            logging.info(f"Create event emitted: {key} = {value}")
+        except Exception as e:
+            logging.error(f"Error emitting create event: {e}")
+
+    def read(self, key: str):
+        try:
+            self.entity.read(key)
+            logging.info(f"Read event emitted: {key}")
+        except Exception as e:
+            logging.error(f"Error emitting read event: {e}")
+
+    def update(self, key: str, value: any):
+        try:
+            self.entity.update(key, value)
+            logging.info(f"Update event emitted: {key} = {value}")
+        except Exception as e:
+            logging.error(f"Error emitting update event: {e}")
+
+    def delete(self, key: str):
+        try:
+            self.entity.delete(key)
+            logging.info(f"Delete event emitted: {key}")
+        except Exception as e:
+            logging.error(f"Error emitting delete event: {e}")

presenters/presenter.py

@@ -0,0 +1,13 @@
+import logging
+from channels.channel import Channel
+
+class Presenter:
+    def __init__(self, channel: Channel):
+        self.channel = channel
+
+    def handle(self, event: str, *args, **kwargs):
+        try:
+            self.channel.emit(event, *args, **kwargs)
+            logging.info(f"Event handled: {event}")
+        except Exception as e:
+            logging.error(f"Error handling event {event}: {e}")

routers/router.py

@@ -0,0 +1,14 @@
+import logging
+from channels.channel import Channel
+
+class Router:
+    def __init__(self, channel: Channel):
+        self.channel = channel
+        self.channel.on('navigate', self.navigate)
+
+    def navigate(self, screen: str):
+        try:
+            logging.info(f"Navigate to {screen}")
+            self.channel.emit('navigate', screen)
+        except Exception as e:
+            logging.error(f"Error navigating to {screen}: {e}")

views/view.py

@@ -0,0 +1,20 @@
+import gradio as gr
+from channels.channel import Channel
+
+class View:
+    def __init__(self, channel: Channel):
+        self.channel = channel
+        self.channel.on('render', self.render)
+        self.channel.on('update', self.update)
+
+    def render(self):
+        with gr.Blocks() as demo:
+            gr.Markdown("## Welcome to VIPER Architecture")
+            gr.Markdown("This is a sample view rendering.")
+            demo.launch()
+
+    def update(self, content: str):
+        with gr.Blocks() as demo:
+            gr.Markdown("## Welcome to VIPER Architecture")
+            gr.Markdown(content)
+            demo.launch()