update fix logger

app.py

@@ -1,10 +1,16 @@
+
 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
+from components.view import View
+
+setup_logging = __import__('logging_config').setup_logging
+setup_logging()
+
+logger = logging.getLogger('app')
 
 def initialize_app():
     # Tạo các thành phần
@@ -26,5 +32,6 @@ def initialize_app():
     router.navigate('Home')
 
 if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-    initialize_app()
+    logger.info("Application started")
+    initialize_app()
+    logger.info("Application finished")

channels/channel.py

@@ -1,5 +1,11 @@
+
 import logging
 
+setup_logging = __import__('logging_config').setup_logging
+setup_logging()
+
+logger = logging.getLogger('channels')
+
 class Event:
     def __init__(self):
         self.listeners = {}
@@ -8,21 +14,21 @@ class Event:
         if event not in self.listeners:
             self.listeners[event] = []
         self.listeners[event].append(listener)
-        logging.info(f"Registered listener for event: {event}")
+        logger.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}")
+            logger.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}")
+                    logger.info(f"Emitted event: {event}")
                 except Exception as e:
-                    logging.error(f"Error emitting event {event}: {e}")
+                    logger.error(f"Error emitting event {event}: {e}")
 
 class Channel:
     def __init__(self):

entities/entity.py

@@ -2,36 +2,41 @@
 from dataclasses import dataclass, field
 import logging
 
+setup_logging = __import__('logging_config').setup_logging
+setup_logging()
+
+logger = logging.getLogger('entities')
+
 @dataclass
 class Entity:
     data: dict = field(default_factory=dict)
 
     def create(self, key: str, value: any):
         if not isinstance(key, str) or value is None:
-            logging.error('Invalid key or value')
+            logger.error('Invalid key or value')
             return
         self.data[key] = value
-        logging.info(f"Create: {key} = {value}")
+        logger.info(f"Create: {key} = {value}")
 
     def read(self, key: str):
         if not isinstance(key, str):
-            logging.error('Invalid key')
+            logger.error('Invalid key')
             return
         value = self.data.get(key)
-        logging.info(f"Read: {key} = {value}")
+        logger.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')
+            logger.error('Invalid key or value')
             return
         self.data[key] = value
-        logging.info(f"Update: {key} = {value}")
+        logger.info(f"Update: {key} = {value}")
 
     def delete(self, key: str):
         if not isinstance(key, str):
-            logging.error('Invalid key')
+            logger.error('Invalid key')
             return
         if key in self.data:
             del self.data[key]
-            logging.info(f"Delete: {key}")
+            logger.info(f"Delete: {key}")

interactors/interactor.py

@@ -1,9 +1,13 @@
+
 import logging
-from channels.channel import Channel
-from entities.entity import Entity
+
+setup_logging = __import__('logging_config').setup_logging
+setup_logging()
+
+logger = logging.getLogger('interactors')
 
 class Interactor:
-    def __init__(self, channel: Channel, entity: Entity):
+    def __init__(self, channel, entity):
         self.channel = channel
         self.entity = entity
         self.channel.on('create', self.create)
@@ -14,27 +18,27 @@ class Interactor:
     def create(self, key: str, value: any):
         try:
             self.entity.create(key, value)
-            logging.info(f"Create event emitted: {key} = {value}")
+            logger.info(f"Create event emitted: {key} = {value}")
         except Exception as e:
-            logging.error(f"Error emitting create event: {e}")
+            logger.error(f"Error emitting create event: {e}")
 
     def read(self, key: str):
         try:
             self.entity.read(key)
-            logging.info(f"Read event emitted: {key}")
+            logger.info(f"Read event emitted: {key}")
         except Exception as e:
-            logging.error(f"Error emitting read event: {e}")
+            logger.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}")
+            logger.info(f"Update event emitted: {key} = {value}")
         except Exception as e:
-            logging.error(f"Error emitting update event: {e}")
+            logger.error(f"Error emitting update event: {e}")
 
     def delete(self, key: str):
         try:
             self.entity.delete(key)
-            logging.info(f"Delete event emitted: {key}")
+            logger.info(f"Delete event emitted: {key}")
         except Exception as e:
-            logging.error(f"Error emitting delete event: {e}")
+            logger.error(f"Error emitting delete event: {e}")

logging_config.py

@@ -0,0 +1,64 @@
+
+import logging
+import logging.config
+
+def setup_logging():
+    logging_config = {
+        'version': 1,
+        'disable_existing_loggers': False,
+        'formatters': {
+            'standard': {
+                'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
+            },
+        },
+        'handlers': {
+            'file_handler': {
+                'class': 'logging.FileHandler',
+                'filename': 'app.log',
+                'formatter': 'standard',
+            },
+            'console_handler': {
+                'class': 'logging.StreamHandler',
+                'formatter': 'standard',
+            },
+        },
+        'loggers': {
+            'app': {
+                'handlers': ['file_handler', 'console_handler'],
+                'level': 'INFO',
+                'propagate': False,
+            },
+            'channels': {
+                'handlers': ['file_handler', 'console_handler'],
+                'level': 'INFO',
+                'propagate': False,
+            },
+            'entities': {
+                'handlers': ['file_handler', 'console_handler'],
+                'level': 'INFO',
+                'propagate': False,
+            },
+            'interactors': {
+                'handlers': ['file_handler', 'console_handler'],
+                'level': 'INFO',
+                'propagate': False,
+            },
+            'presenters': {
+                'handlers': ['file_handler', 'console_handler'],
+                'level': 'INFO',
+                'propagate': False,
+            },
+            'routers': {
+                'handlers': ['file_handler', 'console_handler'],
+                'level': 'INFO',
+                'propagate': False,
+            },
+            'components': {
+                'handlers': ['file_handler', 'console_handler'],
+                'level': 'INFO',
+                'propagate': False,
+            },
+        },
+    }
+
+    logging.config.dictConfig(logging_config)

presenters/presenter.py

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

routers/router.py

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

views/view.py

@@ -1,8 +1,14 @@
+
 import gradio as gr
-from channels.channel import Channel
+import logging
+
+setup_logging = __import__('logging_config').setup_logging
+setup_logging()
+
+logger = logging.getLogger('components')
 
 class View:
-    def __init__(self, channel: Channel):
+    def __init__(self, channel):
         self.channel = channel
         self.channel.on('render', self.render)
         self.channel.on('update', self.update)
@@ -12,9 +18,11 @@ class View:
             gr.Markdown("## Welcome to VIPER Architecture")
             gr.Markdown("This is a sample view rendering.")
             demo.launch()
+        logger.info("Rendered view")
 
     def update(self, content: str):
         with gr.Blocks() as demo:
             gr.Markdown("## Welcome to VIPER Architecture")
             gr.Markdown(content)
-            demo.launch()
+            demo.launch()
+        logger.info(f"Updated view with content: {content}")