First commit.

Dockerfile

@@ -0,0 +1,23 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application's code into the container at /app
+COPY . .
+
+# Make port 7860 available to the world outside this container
+EXPOSE 7860
+
+# Define environment variable
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+# Run app.py when the container launches
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,164 @@
+import gradio as gr
+import json
+from filter_utils import filter_lines
+
+def add_filter(filters, filter_type, filter_value, case_sensitive):
+    if filter_value:
+        filters.append({"type": filter_type, "value": filter_value, "case_sensitive": case_sensitive})
+    return filters, ""
+
+def remove_filter(filters, selected_filter):
+    if selected_filter:
+        parts = selected_filter.split(" - ")
+        if len(parts) == 3:
+            filter_type, filter_value, case_str = parts
+            case_sensitive = case_str == "Case Sensitive: True"
+            for f in filters:
+                if f["type"] == filter_type and f["value"] == filter_value and f["case_sensitive"] == case_sensitive:
+                    filters.remove(f)
+                    break
+    return filters, None
+
+def apply_filters(file, filters):
+    if file is not None:
+        with open(file.name) as f:
+            lines = f.readlines()
+
+        if not filters:
+            return "".join(lines)
+
+        processed_lines = lines
+        for f in filters:
+            filter_type = f["type"]
+            value = f["value"]
+            case = f["case_sensitive"]
+
+            if filter_type == "Include Text":
+                processed_lines = filter_lines(processed_lines, include_text=value, case_sensitive=case)
+            elif filter_type == "Exclude Text":
+                processed_lines = filter_lines(processed_lines, exclude_text=value, case_sensitive=case)
+            elif filter_type == "Include Regex":
+                processed_lines = filter_lines(processed_lines, include_regex=value, case_sensitive=case)
+            elif filter_type == "Exclude Regex":
+                processed_lines = filter_lines(processed_lines, exclude_regex=value, case_sensitive=case)
+
+        return "".join(processed_lines)
+    return ""
+
+def update_filter_list(filters):
+    filter_strings = [f'{f["type"]} - {f["value"]} - Case Sensitive: {f["case_sensitive"]}' for f in filters]
+    return gr.update(choices=filter_strings)
+
+def save_filters(filters):
+    with open("filters.json", "w") as f:
+        json.dump(filters, f)
+    return "filters.json"
+
+def load_filters(filter_file):
+    if filter_file is not None:
+        with open(filter_file.name) as f:
+            return json.load(f)
+    return []
+
+def save_filtered_log(log_content):
+    if log_content:
+        with open("filtered_log.txt", "w") as f:
+            f.write(log_content)
+        return "filtered_log.txt"
+    return None
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    filters_state = gr.State([])
+
+    gr.Markdown("## Log File Viewer")
+
+    with gr.Row():
+        file_input = gr.File(label="Upload Log File")
+
+    gr.Markdown("### Filters")
+
+    with gr.Row():
+        filter_type = gr.Dropdown([
+            "Include Text", "Exclude Text", "Include Regex", "Exclude Regex"
+        ], label="Filter Type")
+        filter_value = gr.Textbox(label="Filter Value")
+        case_sensitive_checkbox = gr.Checkbox(label="Case Sensitive", value=True)
+        with gr.Column(scale=0):
+            add_filter_button = gr.Button("Add Filter")
+            save_filters_button = gr.Button("Save Filters")
+            load_filters_file = gr.UploadButton("Load Filters (.json)", file_types=[".json"])
+
+    
+
+    with gr.Row():
+        applied_filters_list = gr.Radio(label="Applied Filters", interactive=True)
+        remove_filter_button = gr.Button("Remove Selected Filter")
+
+    with gr.Row():
+        save_filtered_log_button = gr.Button("Save Filtered Log")
+    text_output = gr.Textbox(label="Log Content", lines=20, max_lines=1000, interactive=False, elem_id="log_content")
+
+    # Event Handlers
+    add_filter_button.click(
+        add_filter,
+        inputs=[filters_state, filter_type, filter_value, case_sensitive_checkbox],
+        outputs=[filters_state, filter_value]
+    ).then(
+        update_filter_list,
+        inputs=filters_state,
+        outputs=applied_filters_list
+    ).then(
+        apply_filters,
+        inputs=[file_input, filters_state],
+        outputs=text_output
+    )
+
+    remove_filter_button.click(
+        remove_filter,
+        inputs=[filters_state, applied_filters_list],
+        outputs=[filters_state, applied_filters_list]
+    ).then(
+        update_filter_list,
+        inputs=filters_state,
+        outputs=applied_filters_list
+    ).then(
+        apply_filters,
+        inputs=[file_input, filters_state],
+        outputs=text_output
+    )
+
+    save_filters_button.click(
+        save_filters,
+        inputs=filters_state,
+        outputs=gr.File(label="Download Filter File")
+    )
+
+    load_filters_file.upload(
+        load_filters,
+        inputs=load_filters_file,
+        outputs=filters_state
+    ).then(
+        update_filter_list,
+        inputs=filters_state,
+        outputs=applied_filters_list
+    ).then(
+        apply_filters,
+        inputs=[file_input, filters_state],
+        outputs=text_output
+    )
+
+    file_input.upload(
+        apply_filters,
+        inputs=[file_input, filters_state],
+        outputs=text_output
+    )
+
+    save_filtered_log_button.click(
+        save_filtered_log,
+        inputs=text_output,
+        outputs=gr.File(label="Download Filtered Log")
+    )
+
+if __name__ == "__main__":
+    demo.launch()
+    demo.launch()

design.md

@@ -0,0 +1,79 @@
+# LogViewer Application Design
+
+## 1. Overview
+
+LogViewer is a web-based application built with Python and Gradio that allows users to upload and inspect log files. It provides dynamic filtering capabilities to help users analyze log data by including or excluding lines based on text or regular expressions.
+
+## 2. Components
+
+The application consists of two main Python files:
+
+### 2.1. `app.py`
+
+This is the main application file that creates the user interface and handles all user interactions.
+
+*   **UI Structure:** The UI is built using `gradio.Blocks` with the `Soft` theme. It includes:
+    *   A file upload component (`gr.File`) for loading log files.
+    *   A large, non-interactive textbox (`gr.Textbox`) to display the processed log content.
+    *   A section for adding new filters, containing:
+        *   A dropdown (`gr.Dropdown`) to select the filter type (Include/Exclude Text, Include/Exclude Regex).
+        *   A textbox (`gr.Textbox`) to input the filter pattern.
+        *   A checkbox (`gr.Checkbox`) to control case sensitivity for the filter.
+        *   An "Add Filter" button (`gr.Button`).
+        *   "Save Filters" button (`gr.Button`) to download the current filter set as a JSON file.
+        *   "Load Filters" button (`gr.UploadButton`) to upload a JSON file and apply saved filters.
+    *   A section to display and manage active filters:
+        *   A radio button group (`gr.Radio`) that lists the currently applied filters, showing their type, value, and case sensitivity.
+        *   A "Remove Selected Filter" button (`gr.Button`).
+    *   A "Save Filtered Log" button (`gr.Button`) to download the currently displayed filtered log content.
+
+*   **State Management:**
+    *   A `gr.State` object (`filters_state`) is used to maintain the list of active filters as a list of dictionaries. Each dictionary represents a single filter.
+
+*   **Core Logic:**
+    *   **`add_filter()`:** Adds a new filter dictionary to the `filters_state` list.
+    *   **`remove_filter()`:** Removes a filter from the `filters_state` list based on the user's selection.
+    *   **`apply_filters()`:** This is the main processing function. It reads the uploaded file and applies the sequence of filters stored in `filters_state` by calling the `filter_lines` utility function for each filter.
+    *   **`update_filter_list()`:** Generates a list of strings from the `filters_state` list to display it in the UI.
+    *   **`save_filters()`:** Saves the current `filters_state` to a JSON file.
+    *   **`load_filters()`:** Loads filters from a JSON file into `filters_state`.
+    *   **`save_filtered_log()`:** Saves the current content of the log display to a text file.
+
+*   **Event Handling:**
+    *   Uploading a file triggers `apply_filters`.
+    *   Clicking "Add Filter" triggers `add_filter`, then `update_filter_list`, and finally `apply_filters`.
+    *   Clicking "Remove Selected Filter" triggers `remove_filter`, then `update_filter_list`, and finally `apply_filters`.
+    *   Clicking "Save Filters" triggers `save_filters`.
+    *   Uploading a file to "Load Filters" triggers `load_filters`, then `update_filter_list`, and finally `apply_filters`.
+    *   Clicking "Save Filtered Log" triggers `save_filtered_log`.
+
+### 2.2. `filter_utils.py`
+
+This module provides the core filtering logic.
+
+*   **`filter_lines()`:** A pure function that takes a list of text lines and applies a single filtering criterion (e.g., include text, exclude regex). It handles both plain text and regular expression matching, with an option for case sensitivity. It returns a new list of filtered lines.
+
+### 2.3. `timestamp_utils.py`
+
+This module provides utilities for parsing and filtering log lines based on timestamps.
+
+*   **`parse_timestamp()`:** Attempts to parse a timestamp from a log line. Designed to be extensible for various timestamp formats.
+*   **`get_timestamp_range()`:** Extracts the earliest and latest timestamps from a list of log lines.
+*   **`filter_by_time_range()`:** Filters log lines to include only those within a specified time range, based on parsed timestamps.
+
+## 3. User Interaction Flow
+
+1.  The user opens the application in their browser.
+2.  The user uploads a log file using the file upload component. The log content is immediately displayed.
+3.  To filter the log, the user selects a filter type, enters a value, and clicks "Add Filter".
+4.  The filter is added to the "Applied Filters" list, and the log view is automatically updated to reflect the new filter.
+5.  The user can add multiple filters sequentially. Each new filter is applied to the result of the previous ones.
+6.  To remove a filter, the user selects it from the "Applied Filters" radio group.
+7.  The user then clicks the "Remove Selected Filter" button.
+8.  The filter is removed from the list, and the log view is updated to reflect the change.
+9.  The user can save the current set of filters by clicking the "Save Filters" button, which will prompt a file download.
+10. The user can load a previously saved set of filters by clicking the "Load Filters" button and selecting a JSON file.
+
+11. The user can save the currently displayed filtered log content by clicking the "Save Filtered Log" button, which will prompt a file download.
+
+This design allows for a flexible and interactive way to analyze log files by building a chain of filters.

docker-compose.yml

@@ -0,0 +1,7 @@
+services:
+  logviewer:
+    build: .
+    ports:
+      - "7860:7860"
+    volumes:
+      - .:/app

filter_utils.py

@@ -0,0 +1,56 @@
+
+import re
+
+def filter_lines(lines, include_text=None, exclude_text=None, include_regex=None, exclude_regex=None, case_sensitive=True):
+    """
+    Filters a list of text lines based on include/exclude criteria for both plain text and regex.
+
+    Args:
+        lines (list): A list of strings, where each string is a line of text.
+        include_text (str, optional): Text that must be present in a line for it to be included.
+        exclude_text (str, optional): Text that must not be present in a line for it to be included.
+        include_regex (str, optional): A regex pattern that a line must match to be included.
+        exclude_regex (str, optional): A regex pattern that a line must not match to be included.
+        case_sensitive (bool, optional): If False, all text comparisons will be case-insensitive. Defaults to True.
+
+    Returns:
+        list: A new list of strings containing the filtered lines.
+    """
+    filtered = lines
+
+    flags = 0 if case_sensitive else re.IGNORECASE
+
+    # Include text filter
+    if include_text:
+        if case_sensitive:
+            filtered = [line for line in filtered if include_text in line]
+        else:
+            filtered = [line for line in filtered if include_text.lower() in line.lower()]
+
+    # Exclude text filter
+    if exclude_text:
+        if case_sensitive:
+            filtered = [line for line in filtered if exclude_text not in line]
+        else:
+            filtered = [line for line in filtered if exclude_text.lower() not in line.lower()]
+
+    # Include regex filter
+    if include_regex:
+        try:
+            pattern = re.compile(include_regex, flags)
+            filtered = [line for line in filtered if pattern.search(line)]
+        except re.error as e:
+            # Handle invalid regex gracefully, maybe log the error or return an empty list
+            print(f"Invalid include regex: {e}")
+            return []
+
+    # Exclude regex filter
+    if exclude_regex:
+        try:
+            pattern = re.compile(exclude_regex, flags)
+            filtered = [line for line in filtered if not pattern.search(line)]
+        except re.error as e:
+            print(f"Invalid exclude regex: {e}")
+            return []
+
+    return filtered

launch.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+source ~/.virtualenvs/LogViewer/bin/activate
+python "/media/topguy/T7 Shield/AIPlayGround/LogViewer/app.py"

requirements.txt

@@ -0,0 +1 @@
+gradio

timestamp_utils.py

@@ -0,0 +1,59 @@
+import datetime
+import re
+
+def parse_timestamp(log_line: str) -> datetime.datetime | None:
+    """
+    Attempts to parse a timestamp from the beginning of a log line.
+    This is a placeholder and should be extended to handle various timestamp formats.
+    """
+    # Example: YYYY-MM-DD HH:MM:SS.milliseconds or YYYY-MM-DDTHH:MM:SS,SSS
+    # This regex is a starting point and might need to be adjusted for specific log formats.
+    match = re.match(r'^(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[.,]\d{3})', log_line)
+    if match:
+        try:
+            # Try parsing with milliseconds
+            return datetime.datetime.strptime(match.group(1).replace('T', ' ').replace(',', '.'), '%Y-%m-%d %H:%M:%S.%f')
+        except ValueError:
+            pass
+    
+    # Add more parsing attempts for other common formats here
+    # Example: "MMM DD HH:MM:SS" (e.g., "Jun 28 10:30:00")
+    match = re.match(r'^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}', log_line)
+    if match:
+        try:
+            # For this format, we might need to assume the current year or pass it in
+            # For simplicity, let's just return None for now if it's not a full datetime
+            pass
+        except ValueError:
+            pass
+
+    return None
+
+def get_timestamp_range(log_lines: list[str]) -> tuple[datetime.datetime | None, datetime.datetime | None]:
+    """
+    Parses timestamps from a list of log lines and returns the earliest and latest timestamps found.
+    """
+    min_ts = None
+    max_ts = None
+    for line in log_lines:
+        ts = parse_timestamp(line)
+        if ts:
+            if min_ts is None or ts < min_ts:
+                min_ts = ts
+            if max_ts is None or ts > max_ts:
+                max_ts = ts
+    return min_ts, max_ts
+
+def filter_by_time_range(log_lines: list[str], start_time: datetime.datetime | None, end_time: datetime.datetime | None) -> list[str]:
+    """
+    Filters log lines to include only those within a specified time range.
+    Lines without a parseable timestamp are excluded.
+    """
+    filtered_lines = []
+    for line in log_lines:
+        ts = parse_timestamp(line)
+        if ts:
+            if (start_time is None or ts >= start_time) and \
+               (end_time is None or ts <= end_time):
+                filtered_lines.append(line)
+    return filtered_lines