libsrg_log2web 1.0.3__tar.gz

libsrg_log2web-1.0.3/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: libsrg_log2web
+Version: 1.0.3
+Summary: Multithreded logging to webpage
+Author-email: Steve Goncalo <steven@goncalo.us>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Natural Language :: English
+Classifier: Topic :: Utilities
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.14
+Requires-Dist: flask>=3.1.2
+Requires-Dist: libsrg>=6.0.4

libsrg_log2web-1.0.3/libsrg_log2web/Demo.py

@@ -0,0 +1,70 @@
+import platform
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from time import sleep
+
+from libsrg_log2web import FlaskApp, Log2Web
+from libsrg.LoggingAppBase import LoggingAppBase
+
+class Main(LoggingAppBase):
+
+    def __init__(self):
+
+
+        fmt = "%(asctime)s %(levelname)-8s %(lineno)4d %(name) 20s.%(funcName)-22s %(threadName)-12s-- %(message)s"
+        self.file0 = Path(__file__)
+        self.project_path = self.file0.parent
+        self.node = platform.node()
+        self.node0 = self.node.split(".")[0]
+
+        logfile_path = Path.home() / "Log2Web.log"
+        logfile_path.unlink(missing_ok=True)
+        self.logfile_name = str(logfile_path)
+        super().__init__(logfile=self.logfile_name, format=fmt)
+
+        self.bridge= Log2Web.Bridge(self.run, FlaskApp.app, title="Log2Web Demo",
+                                    headertext="Log2Web Demo Threads")
+        self.bridge.run()
+
+
+    def run(self)->None:
+        self.logger.info("callback to application")
+
+        executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix="POOL_")
+        futures = [executor.submit(self.app_thread_target,i ) for i in range(10)]
+
+        # sleep(10)
+        executor.shutdown(wait=True)
+
+
+        self.logger.debug("Bye")
+        # """Raises a signal to main thread which is WebGUI to shut down."""
+        # signal.raise_signal(2)
+
+    def app_thread_target(self,n:int)->None:
+
+        Log2Web.send_log_op(Log2Web.LogOps.NEW_THREAD)
+        self.logger.info(f"app {n} starting")
+        for i in range(20):
+                match i:
+                    case 3:
+                        Log2Web.send_log_op(Log2Web.LogOps.BG_COLOR, 'pink')
+                        Log2Web.send_log_op(Log2Web.LogOps.FG_COLOR, 'blue')
+                    case 5:
+                        Log2Web.send_log_op(Log2Web.LogOps.BG_COLOR, 'black')
+                        Log2Web.send_log_op(Log2Web.LogOps.FG_COLOR, 'white')
+                    case 7:
+                        Log2Web.send_log_op(Log2Web.LogOps.BG_COLOR, 'cyan')
+                        Log2Web.send_log_op(Log2Web.LogOps.FG_COLOR, 'red')
+
+                if i == n:
+                    self.logger.warning(f"app {n=} cycle {i=}")
+                else:
+                    self.logger.info(f"app {n=} cycle {i=}")
+
+                sleep(1+n/10.)
+
+        Log2Web.send_log_op(Log2Web.LogOps.THREAD_EXIT)
+
+if __name__=="__main__":
+    main = Main()

libsrg_log2web-1.0.3/libsrg_log2web/FlaskApp.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+
+from flask import Flask, render_template
+from libsrg_log2web.Log2Web import LogWatcher, Bridge
+
+my_file = __file__
+flask_dir = Path(my_file).parent
+app_dir = flask_dir.parent.parent
+template_dir = flask_dir / "templates"
+static_dir = flask_dir / "static"
+app = Flask(__name__,
+            template_folder=template_dir,
+            static_folder=static_dir)
+
+
+@app.route('/hello')
+def hello_world():  # put the application's code here
+    return 'Hello World!'
+
+
+@app.route('/')
+def display_status():  # put the application's code here
+    watchers = LogWatcher.instance.display()
+    return render_template('status.html',
+                           delay=0.1,
+                           watchers=LogWatcher.instance.display_watchers,
+                           title=Bridge.instance.title,
+                           headertext=Bridge.instance.headertext)
+
+
+if __name__ == '__main__':
+    app.run()

libsrg_log2web-1.0.3/libsrg_log2web/Log2Web.py

@@ -0,0 +1,277 @@
+import logging
+import signal
+import threading
+import webbrowser
+from enum import Enum
+from threading import Thread
+from time import sleep, time
+from typing import Callable, Optional
+
+from flask import Flask
+
+"""
+This module does not import the user's Flask application module or the user's Main module.
+The user's Flask application can include the Log2Web module.
+The user's Main module must import (and instantiate) the user's FlaskApp module.
+
+The User's Main module must connect the FlaskApp module to the Log2Web module via a Bridge object.
+
+As general guidance, attempting to log within the Log2Web module may cause infinite recursion.
+"""
+
+LOGOP = "LOGOP %s"
+
+
+class LogOps(Enum):
+    NEW_THREAD = 1
+    THREAD_EXIT = 2
+    FG_COLOR = 3
+    BG_COLOR = 4
+
+
+def send_log_op(op: LogOps, *args):
+    fmt = LOGOP
+    fmt += " %s" * len(args)
+    # print(f"send op {op=} {args=} {fmt=}")
+    logging.getLogger().info(fmt, op, *args)
+
+
+"""
+ThreadLogWatcher is an object that receives log messages from a given thread and retains information for display.
+"""
+
+status_color = {
+    logging.DEBUG: 'green',
+    logging.INFO: 'blue',
+    logging.WARNING: 'orange',
+    logging.ERROR: 'red',
+    logging.CRITICAL: 'magenta'
+}
+
+
+class ThreadLogWatcher:
+    def __init__(self, thread_id: int):
+        self.thread_id: int = thread_id
+        self.live = True
+        self.time_of_death = None
+        self.record: Optional[logging.LogRecord] = logging.LogRecord(
+            name="No data yet",
+            level=logging.DEBUG,
+            pathname="No data yet",
+            lineno=0,
+            msg="No data yet",
+            args=(),
+            exc_info=None
+        )
+        self.fg = 'green'
+        self.bg = 'white'
+        self.worst = logging.DEBUG
+        self.latest = logging.DEBUG
+        self.tname = "?"
+        self.msg="No message yet"
+
+    def process_log_record(self, record: logging.LogRecord):
+        # print(f"{self.thread_id} {record.getMessage()} {record.message=} {type(record.message)=} {record.args=}")
+        self.record = record
+        self.msg = record.msg
+        self.worst = max(self.worst, record.levelno)
+        self.latest = record.levelno
+        self.tname = record.threadName
+
+    def process_log_op(self, op: LogOps,record: logging.LogRecord, *args):
+        # print(f"PROC OP {self.thread_id}  {op=} {type(op)=} {args=}")
+        self.record = record
+        match op:
+            case LogOps.FG_COLOR:
+                self.fg = args[1]
+            case LogOps.BG_COLOR:
+                self.bg = args[1]
+            case LogOps.NEW_THREAD:
+                pass  # no action, but expected
+            case _:
+                # print(f"Unknown OP {op=} {args=}")
+                pass
+        # print(f"PROC OP results {self.thread_id}  {self.fg=} {self.bg=}")
+
+    # noinspection PyUnusedLocal
+    def terminated(self, op: LogOps, *args):
+        # print(f"TERMINATED {self.thread_id} OP {op.name=} {type(op)=}")
+        self.live = False
+        self.time_of_death = time()
+
+    def time_dead(self, now: float) -> float | None:
+        if self.live:
+            return 0
+        return now - self.time_of_death
+
+    def display_row_start(self) -> str:
+        """HTML lead in"""
+        stat_w = status_color.get(self.worst, 'violet')
+        stat_l = status_color.get(self.latest, 'violet')
+        live_fg = 'green' if self.live else 'black'
+        live_bg = 'white' if self.live else 'lightgrey'
+        out = [
+            f"<td><span style='background-color:{live_bg};color:{live_fg};'>",
+            self.tname if self.live else f"<del>{self.tname}</del>",
+            f"</span></td>",
+
+            f"<td><span style='background-color:white;color:{stat_w};'>",
+            logging.getLevelName(self.worst),
+            f"</span></td>",
+
+            f"<td><div style='background-color:white;color:{stat_l};'>",
+            logging.getLevelName(self.latest),
+            f"</div></td>",
+
+            f"<td><div style='background-color:{self.bg};color:{self.fg};'>",
+            # f"{stat_w=} {stat_l=}<br>"
+        ]
+        return '\n'.join(out)
+
+    def display_row_body(self) -> str:
+        return f"{self.msg} {self.record.filename} {self.record.lineno}"
+
+    @staticmethod
+    def display_row_end() -> str:
+        return "</div></td>"
+
+
+"""
+LogWatcher is a logging handler that can be attached to the logging subsystem to observe
+log messages generated by all threads of the user's application.
+It manages a collection of ThreadLogWatcher objects, one for each thread.
+"""
+
+
+class LogWatcher(logging.Handler):
+    instance: LogWatcher = None
+
+    def __init__(self, *args, **kwargs):
+        """
+        Constructor.
+        :param args: positional arguments passed to logging.Handler
+        :param kwargs: keyword arguments passed to logging.Handler
+        """
+        super().__init__(*args, **kwargs)
+        self.kwargs = kwargs
+        logging.getLogger().addHandler(self)
+        LogWatcher.instance = self
+        self.thread_log_watchers: dict[int, ThreadLogWatcher] = {}
+        self.display_watchers: list[ThreadLogWatcher] = []
+        self.data_event = threading.Event()
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """
+        Emit a record. (record is recorded to queue)
+        :param record:
+        :return:
+        """
+        if record.name == 'werkzeug':
+            return
+
+        self.data_event.set()
+
+        thread = record.thread
+        # tname = f"{record.funcName=} {record.threadName=} {record.name=} {record.filename=}"
+        watcher = self.thread_log_watchers.get(thread, None)
+        oflag = record.msg.startswith(LOGOP)
+        op = record.args[0] if (len(record.args) > 0) and oflag else None  # and (record.message == LOGOP)
+
+        # print(f"EMIT {thread} {op=} {type(op)=} {record.getMessage()} {watcher=} {tname=} {oflag=}")
+        # On termination of a thread, remove the old watcher from the dictionary (but not the list of display watchers).
+        if watcher is not None and (op in [LogOps.NEW_THREAD, LogOps.THREAD_EXIT]):
+            self.thread_log_watchers.pop(thread)
+            watcher.terminated(op)
+            return
+
+        # if there is no watcher for the thread, create one and add to dictionary and list of display watchers.
+        if watcher is None:
+            watcher = ThreadLogWatcher(thread)
+            self.thread_log_watchers[thread] = watcher
+            self.display_watchers.append(watcher)
+
+        if op is None:
+            watcher.process_log_record(record)
+        else:
+            watcher.process_log_op(op, record,*record.args)
+
+    def display(self) -> list[ThreadLogWatcher]:
+        # wait up to 1 second for data to arrive.
+        self.data_event.wait(timeout=1)
+        self.data_event.clear()
+
+        now = time()
+        dead_watchers = [watcher for watcher in self.display_watchers if watcher.time_dead(now) > 5]
+        for watcher in dead_watchers:
+            self.display_watchers.remove(watcher)
+
+        return self.display_watchers.copy()
+
+
+"""
+The bridge object connects the user application and flask application.
+All three are expected to be singletons.
+"""
+
+
+class Bridge:
+    instance: Bridge = None
+
+    def __init__(self,
+                 user_callable: Callable[[], None],
+                 flask_app: Flask,
+                 browser: bool = True,
+                 title: str = "Log2Web",
+                 headertext: str = "Data from threads",
+                 ) -> None:
+        self.user_callable = user_callable
+        self.flask_app = flask_app
+        self.user_thread = Thread(target=self._run_user_in_thread, name="USER_MAIN")
+        Bridge.instance = self
+        self.log_watcher = LogWatcher()
+        self.browser = browser
+
+        self.title = title
+        self.headertext = headertext
+
+    """
+    The run method swaps control of the main thread to the flask application.
+    The user application starts in the main thread. Flask must run in the main thread.
+    A second thread is created to run the user_callable provided in the constructor.
+    This method does not return until the flask application exits.
+    """
+
+    def run(self):
+        self.user_thread.start()
+        self.flask_app.run(host='0.0.0.0', port=8080)
+
+    def _run_user_in_thread(self):
+        """
+        Runs the user callable in a separate thread.
+        On completion, raises a signal to the main thread which is WebGUI to shut down.
+        :return:
+        """
+        try:
+            if self.browser:
+                webbrowser.open("http://localhost:8080")
+            logging.getLogger().info("starting user callable")
+            self.user_callable()
+            logging.getLogger().info("user callable completed")
+            sleep(4)
+        except Exception as e:
+            logging.getLogger().exception(e)
+        finally:
+            logging.getLogger().info("GUI Shutdown")
+            sleep(1)
+            signal.raise_signal(2)
+
+
+class LoggerGUIProxy:
+    @staticmethod
+    def gui_configure(background='white', foreground='black'):
+        send_log_op(LogOps.BG_COLOR, background)
+        send_log_op(LogOps.FG_COLOR, foreground)
+
+    @staticmethod
+    def gui_new_line():
+        send_log_op(LogOps.NEW_THREAD)

libsrg_log2web-1.0.3/libsrg_log2web/static/style.css

@@ -0,0 +1,8 @@
+table.status {
+    border: 1px solid black;
+}
+
+tr.header {
+    background-color: black;
+    color: cyan;
+}

libsrg_log2web-1.0.3/libsrg_log2web/templates/status.html

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="refresh" content="{{ delay }}">
+    <link href="../static/style.css" rel="stylesheet" type="text/css">
+    <title>{{title}}</title>
+</head>
+<body>
+{{headertext}}
+    <table class="status">
+        <tr class="header">
+            <th>Thread</th>
+            <th>Net Status</th>
+            <th>Latest Status</th>
+            <th>Message</th>
+        </tr>
+        {% for watcher in watchers %}
+            <tr>
+            {{ watcher.display_row_start()|safe }}
+            {{ watcher.display_row_body() }}
+            {{ watcher.display_row_end()|safe }}
+
+            </tr>
+        {% endfor %}
+    </table>
+
+</body>
+</html>

libsrg_log2web-1.0.3/libsrg_log2web.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: libsrg_log2web
+Version: 1.0.3
+Summary: Multithreded logging to webpage
+Author-email: Steve Goncalo <steven@goncalo.us>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Natural Language :: English
+Classifier: Topic :: Utilities
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.14
+Requires-Dist: flask>=3.1.2
+Requires-Dist: libsrg>=6.0.4

libsrg_log2web-1.0.3/libsrg_log2web.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+pyproject.toml
+libsrg_log2web/Demo.py
+libsrg_log2web/FlaskApp.py
+libsrg_log2web/Log2Web.py
+libsrg_log2web/__init__.py
+libsrg_log2web.egg-info/PKG-INFO
+libsrg_log2web.egg-info/SOURCES.txt
+libsrg_log2web.egg-info/dependency_links.txt
+libsrg_log2web.egg-info/requires.txt
+libsrg_log2web.egg-info/top_level.txt
+libsrg_log2web/static/style.css
+libsrg_log2web/templates/status.html

libsrg_log2web-1.0.3/libsrg_log2web.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

libsrg_log2web-1.0.3/libsrg_log2web.egg-info/requires.txt

@@ -0,0 +1,2 @@
+flask>=3.1.2
+libsrg>=6.0.4

libsrg_log2web-1.0.3/libsrg_log2web.egg-info/top_level.txt

@@ -0,0 +1 @@
+libsrg_log2web

libsrg_log2web-1.0.3/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "libsrg_log2web"
+version = "1.0.3"
+description = "Multithreded logging to webpage"
+requires-python = ">=3.14"
+dependencies = [
+    "flask>=3.1.2",
+    "libsrg>=6.0.4",
+]
+
+
+authors = [{name="Steve Goncalo", email="steven@goncalo.us"}]
+classifiers = [
+    "Programming Language :: Python :: 3.14",
+    "Development Status :: 5 - Production/Stable",
+#    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Natural Language :: English",
+    "Topic :: Utilities",
+    "Intended Audience :: Developers"
+]
+#license = {text="MIT"}
+license = "MIT"
+
+[tool.uv]
+"link-mode"="symlink"
+
+[dependency-groups]
+dev = [
+    "build>=1.2.2.post1",
+    "twine>=6.1.0",
+]
+
+
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["libsrg_log2web"]
+
+[tool.setuptools.package-data]
+# Include all .txt and .rst files in the 'hello' package
+#"hello" = ["*.txt", "*.rst"]
+# Include all .png files in all packages
+"libsrg_log2web" = ["static/*","templates/*"]

libsrg_log2web-1.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+