Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+src/venv/Lib/site-packages/gradio/frpc_windows_amd64_v0.3 filter=lfs diff=lfs merge=lfs -text
+src/venv/Lib/site-packages/gradio/templates/frontend/assets/Canvas3D-CBtQcOmf.js.map filter=lfs diff=lfs merge=lfs -text
+src/venv/Lib/site-packages/gradio/templates/node/build/client/_app/immutable/chunks/Canvas3D.kwvn8xU9.js.br filter=lfs diff=lfs merge=lfs -text
+src/venv/Lib/site-packages/gradio/templates/node/build/server/chunks/Canvas3D-CBRlDVSB.js.map filter=lfs diff=lfs merge=lfs -text
+src/venv/Lib/site-packages/gradio/templates/node/build/server/chunks/PlotlyPlot-P3y0I-J2.js.map filter=lfs diff=lfs merge=lfs -text
+src/venv/Lib/site-packages/numpy.libs/libscipy_openblas64_-c16e4918366c6bc1f1cd71e28ca36fc0.dll filter=lfs diff=lfs merge=lfs -text
+src/venv/Scripts/ruff.exe filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,27 @@
+*.py[cod]
+__pycache__/
+*.so
+.Python
+.eggs/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.gradio/
+.gradio/certificate.pem
+
+node_modules/
+.svelte-kit/
+.vite/
+
+venv/
+.env/
+.venv/
+env/
+
+.vscode/
+.idea/
+*.swp
+*.swo
+
+.DS_Store

README.md

@@ -1,12 +1,193 @@
----
-title: Gradio Vistimeline
-emoji: 📉
-colorFrom: purple
-colorTo: pink
-sdk: gradio
-sdk_version: 5.9.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+tags: [gradio-custom-component, timeline, vis timeline, vis-timeline, vis.js]
+title: gradio_vistimeline
+short_description: Gradio implementation for the vis.js Timeline library
+colorFrom: blue
+colorTo: yellow
+sdk: gradio
+pinned: false
+app_file: app.py
+---
+<h1 style='text-align: center; margin-bottom: 1rem'> Gradio vis.js Timeline </h1>
+
+<div style="display: flex; flex-direction: row; justify-content: center">
+<img style="display: block; padding-right: 5px; height: 20px;" alt="Static Badge" src="https://img.shields.io/pypi/v/gradio_vistimeline">
+<a href="https://github.com/Yelorix/gradio-vis-timeline" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/github-white?logo=github&logoColor=black"></a>
+<a href="https://huggingface.co/spaces/Yelorix/gradio_vistimeline" target="_blank"><img alt="Open in Spaces" src="https://huggingface.co/datasets/huggingface/badges/resolve/main/open-in-hf-spaces-sm-dark.svg"></a>
+</div>
+
+A Gradio component that implements the [vis.js Timeline](https://github.com/visjs/vis-timeline) visualization library, allowing you to create interactive timelines in your Gradio apps.
+
+**Resources:**
+- [Timeline Examples](https://visjs.github.io/vis-timeline/examples/timeline/)
+- [Timeline Documentation](https://visjs.github.io/vis-timeline/docs/timeline/)
+- [Dataset Documentation](https://visjs.github.io/vis-data/data/dataset.html)
+
+## Installation
+
+```bash
+pip install gradio_vistimeline
+```
+
+## Usage
+
+```python
+import gradio as gr
+from gradio_vistimeline import VisTimeline
+
+demo = gr.Interface(
+    lambda x: x,
+    VisTimeline(
+        value={
+            "items": [
+                {"content": "Item 1", "start": "2024-12-2", "end": "2024-12-10"},
+                {"content": "Item 2", "start": "2024-12-14"}
+            ]
+        },
+        options={
+            "start": "2024-12-1",
+            "end": "2024-12-15",
+            "editable": True
+        }
+    ),
+    "json"
+)
+
+if __name__ == "__main__":
+    demo.launch()
+```
+
+## `VisTimeline`
+
+### Features
+
+- Interactive timeline visualization
+- Integration of vis.js Timeline includes:
+    - Items
+    - Ranges
+    - Points
+    - Background items
+    - Groups
+    - Subgroups
+- Pass options object during instantiation
+- Styled with the gradio style variables
+- Gradio events for editing data and selecting items
+
+### Value Data Format
+
+The timeline accepts a value in the following format:
+
+```python
+{
+    "groups": [
+        {
+            "id": "group_id", 
+            "content": "Group Name" # Optional
+        }
+    ],
+    "items": [
+        {
+            "content": "Item content",
+            "start": "2024-01-01",  # ISO date string or Unix timestamp
+            "end": "2024-01-05",    # Optional
+            "group": "group_id",    # Optional
+        }
+    ]
+}
+```
+
+Or as a VisTimelineData object:
+
+```python
+from gradio_vistimeline import VisTimelineGroup, VisTimelineItem, VisTimelineData
+
+value = VisTimelineData(
+    groups=[
+        VisTimelineGroup(
+            id="group_id", 
+            content="Group Name"   # Optional
+        )
+    ],
+    items=[
+        VisTimelineItem(
+            content="Item content",
+            start="2024-01-01",    # ISO date string or Unix timestamp
+            end="2024-01-05",      # Optional
+            group="group_id"       # Optional
+        )
+    ]
+)
+```
+
+### Events
+
+| name | description |
+|:-----|:------------|
+| `load` | Triggered when the component is mounted for the first time |
+| `change` | Triggered when the timeline value changes through any means |
+| `input` | Triggered when a user directly modifies timeline items (add/remove/update) |
+| `select` | Triggered when clicking the timeline |
+| `item_select` | Triggered when items are selected or unselected |
+
+### Configuration
+
+#### vis.js Timeline Options
+
+The component accepts all configuration options supported by vis.js Timeline. Some commonly used options:
+
+```python
+options = {
+    "editable": True,             # Enable item editing
+    "multiselect": True,          # Allow selecting multiple items
+    "showCurrentTime": True,      # Show a marker for current time
+    "stack": True,                # Stack overlapping items
+    "zoomable": True              # Allow zooming the timeline
+}
+```
+
+For a complete list of options, see the [vis.js Timeline documentation](https://visjs.github.io/vis-timeline/docs/timeline/).
+
+#### Component-Specific Options
+
+**Data Synchronization**
+```python
+VisTimeline(
+    value=value,
+    preserve_old_content_on_value_change=True  # Default: False
+)
+```
+Controls how the timeline updates their groups and items DataSets when the component value changes:
+- `False`: Clears and reinitializes all DataSets to ensure perfect sync with the Gradio component value
+- `True`: Merges new data with existing content (updates existing items, adds new ones, removes missing ones)
+
+Defaulted to false to ensure the value matches the visualization on the timeline.
+
+Changing it to true reduces visual flicker when dragging items around. 
+Desync is only a real risk in this mode when you edit item ID's or add/remove item properties of existing items.
+
+**JavaScript Integration**
+```python
+VisTimeline(
+    value=value,
+    elem_id="my-timeline"  # Optional
+)
+```
+When `elem_id` is set, the timeline instance becomes available in JavaScript as `window.visTimelineInstances["my-timeline"]`, allowing easy access through custom scripts.
+
+**Styling Items**
+The component provides pre-defined color classes matching Gradio's theme colors. Apply them by setting an item's `className`:
+
+```python
+item = {
+    "content": "Colored item",
+    "start": "2024-01-01",
+    "className": "color-primary-500"  # Uses Gradio's primary-500 color
+}
+```
+
+Available color classes follow the pattern:
+- `color-primary-[50-950]`
+- `color-secondary-[50-950]`
+- `color-neutral-[50-950]`
+
+Custom styles can be applied by defining your own CSS classes.

app.py

@@ -0,0 +1,475 @@
+import datetime as dt
+import gradio as gr
+import json
+import numpy as np
+import os
+from datetime import timedelta, date, datetime
+from gradio_vistimeline import VisTimeline, VisTimelineData
+
+# --- Region: Handlers for demo tab 1 ---
+def pull_from_timeline(timeline):
+    """Convert timeline data to JSON string for display"""
+    if hasattr(timeline, "model_dump"):
+        data = timeline.model_dump(exclude_none=True)
+    else:
+        data = timeline
+    return json.dumps(data, indent=2)
+
+def push_to_timeline(json_str):
+    """Convert JSON string to timeline data"""
+    try:
+        return VisTimelineData.model_validate_json(json_str)
+    except Exception as e:
+        print(f"Error parsing JSON: {e}")
+        return VisTimelineData(groups=[], items=[])
+
+def on_timeline_change():
+    return f"Most recent value change event:\n{get_now()}"
+
+def on_timeline_input(event_data: gr.EventData):
+    return f"Most recent input event:\nAction: '{event_data._data}' at {get_now()}"
+
+def on_timeline_select():
+    return f"Most recent timeline selected event::\n{get_now()}"
+
+def on_item_select(timeline, event_data: gr.EventData):
+    selected_ids = event_data._data # A collection of selected item IDs that can be str or int: ["example", 0, "example2"]
+    items = timeline.items
+
+    if selected_ids:
+        first_id = selected_ids[0]
+        for item in items:
+            if item.id == first_id:
+                content = getattr(item, 'content', 'Unknown')
+                return f"Currently selected item:\nContent: \"{content}\"\nID: \"{first_id}\""
+    
+    return "Currently selected item:\nNone"
+
+# --- Region: Handlers for demo tab 1 ---
+def update_table(timeline):
+    if hasattr(timeline, "model_dump"):
+        data = timeline.model_dump(exclude_none=True)
+    else:
+        data = timeline
+    
+    items = data["items"]
+    track_length_ms = get_grouped_item_end_in_ms(items, "track-length")
+
+    rows = []
+    for item in items:
+        if item["content"] != "":
+            duration = calculate_and_format_duration(item["start"], item.get("end"), track_length_ms)
+            rows.append([
+                item["content"],
+                format_date_to_milliseconds(item["start"]),
+                duration
+            ])
+    
+    return gr.DataFrame(
+        value=rows,
+        headers=["Item Name", "Start Time", "Duration"]
+    )
+
+# --- Region: Handlers for demo tab 2 ---
+def update_audio(timeline):
+    """
+    Handler function for generating audio from timeline data.
+    Returns audio data in format expected by Gradio's Audio component.
+    """
+    audio_data, sample_rate = generate_audio_from_timeline(timeline)
+    # Convert to correct shape and data type for Gradio Audio
+    # Gradio expects a 2D array with shape (samples, channels)
+    audio_data = audio_data.reshape(-1, 1)  # Make it 2D with 1 channel
+    return (sample_rate, audio_data)
+
+def generate_audio_from_timeline(timeline_data, sample_rate=44100):
+    """
+    Generate audio from timeline items containing frequency information.
+    
+    Args:
+        timeline_data: Timeline data containing items with start/end times in milliseconds
+        sample_rate: Audio sample rate in Hz (default 44100)
+        
+    Returns:
+        Tuple of (audio_data: np.ndarray, sample_rate: int)
+    """
+    # Get all items from the timeline
+    if hasattr(timeline_data, "model_dump"):
+        data = timeline_data.model_dump(exclude_none=True)
+    else:
+        data = timeline_data
+    
+    items = data["items"]
+    
+    # Find the track length from the background item
+    track_length_ms = get_grouped_item_end_in_ms(items, "track-length")
+    
+    # Convert milliseconds to samples
+    total_samples = int((track_length_ms / 1000) * sample_rate)
+    
+    # Initialize empty audio buffer
+    audio_buffer = np.zeros(total_samples)
+    
+    # Frequency mapping
+    freq_map = {
+        1: 440.0,
+        2: 554.37,
+        3: 659.26
+    }
+    # Generate sine waves for each item
+    for item in items:
+        id = item.get("id", 0)
+        start_time = parse_date_to_milliseconds(item["start"])
+        end_time = parse_date_to_milliseconds(item["end"])
+
+        # Skip items that are completely outside the valid range
+        if end_time <= 0 or start_time >= track_length_ms or start_time >= end_time:
+            continue
+            
+        # Clamp times to valid range
+        start_time = max(0, min(start_time, track_length_ms))
+        end_time = max(0, min(end_time, track_length_ms))
+
+        if id in freq_map:
+            freq = freq_map[id]
+            
+            # Convert millisecond timestamps to sample indices
+            start_sample = int((start_time / 1000) * sample_rate)
+            end_sample = int((end_time / 1000) * sample_rate)
+            
+            # Generate time array for this segment
+            t = np.arange(start_sample, end_sample)
+            
+            # Generate sine wave
+            duration = end_sample - start_sample
+            envelope = np.ones(duration)
+            fade_samples = min(int(0.10 * sample_rate), duration // 2)  # 100ms fade or half duration
+            envelope[:fade_samples] = np.linspace(0, 1, fade_samples)
+            envelope[-fade_samples:] = np.linspace(1, 0, fade_samples)
+            
+            wave = 0.2 * envelope * np.sin(2 * np.pi * freq * t / sample_rate)
+            
+            # Add to buffer
+            audio_buffer[start_sample:end_sample] += wave
+    
+    # Normalize to prevent clipping
+    max_val = np.max(np.abs(audio_buffer))
+    if max_val > 0:
+        audio_buffer = audio_buffer / max_val
+    
+    return (audio_buffer, sample_rate)
+
+# Helper function to get hard-coded track-length from timeline value
+def get_grouped_item_end_in_ms(items, group_id):
+    default_length = 6000
+    for item in items:
+        if item.get("group") == group_id:
+            return parse_date_to_milliseconds(item.get("end", default_length))
+    return default_length
+
+# --- Region: Demo specific datetime helper functions ---
+def calculate_and_format_duration(start_date, end_date, max_range):
+    """Calculate the seconds between two datetime inputs and format the result with up to 2 decimals."""
+    if not end_date:
+        return "0s"
+
+    # Convert dates to milliseconds
+    start_ms = max(0, parse_date_to_milliseconds(start_date))
+    end_ms = min(max_range, parse_date_to_milliseconds(end_date))
+
+    if end_ms < start_ms:
+        return "0s"
+
+    # Calculate duration in seconds
+    duration = (end_ms - start_ms) / 1000
+
+    # Format to remove trailing zeroes after rounding to 2 decimal places
+    formatted_duration = f"{duration:.2f}".rstrip("0").rstrip(".")
+    return f"{formatted_duration}s"
+
+def format_date_to_milliseconds(date):
+    """Format input (ISO8601 string or milliseconds) to mm:ss.SSS."""
+    date_in_milliseconds = max(0, parse_date_to_milliseconds(date))
+    time = timedelta(milliseconds=date_in_milliseconds)
+
+    # Format timedelta into mm:ss.SSS
+    minutes, seconds = divmod(time.seconds, 60)
+    milliseconds_part = time.microseconds // 1000
+    return f"{minutes:02}:{seconds:02}.{milliseconds_part:03}"
+
+def parse_date_to_milliseconds(date):
+    """Convert input (ISO8601 string or milliseconds) milliseconds"""
+    if isinstance(date, int):  # Input is already in milliseconds (Unix timestamp)
+        return date
+    elif isinstance(date, str):  # Input is ISO8601 datetime string
+        dt = datetime.fromisoformat(date.replace("Z", "+00:00"))
+        epoch = datetime(1970, 1, 1, tzinfo=dt.tzinfo) # Calculate difference from Unix epoch
+        return int((dt - epoch).total_seconds() * 1000)
+    else:
+        return 0  # Fallback for unsupported types
+
+def get_now():
+    """Returns current time in HH:MM:SS format"""
+    return datetime.now().strftime("%H:%M:%S")
+
+TIMELINE_ID = "dateless_timeline"
+AUDIO_ID = "timeline-audio"
+
+# Example for how to access the timeline through JavaScript
+# In this case, to bind the custom time bar of the timeline to be in sync with the audio component
+# Read the JavaScript file
+js_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'custom_time_control.js')
+with open(js_path, 'r') as f:
+    js_content = f.read()
+script = f"""<script>{js_content}</script>"""
+style = f"""<style>.vis-custom-time.{TIMELINE_ID} {{pointer-events: none !important;}}</style>"""
+head = script + style
+
+# --- Region: Gradio ---
+with gr.Blocks(head=head) as demo:
+    today = date.today()
+    day_offset = lambda days: (today + dt.timedelta(days=days)).isoformat()
+
+    gr.Markdown("# Vis.js Timeline Component Demo")
+    
+    with gr.Tabs():
+        # --- Tab 1: Basic Timeline with Events ---
+        with gr.Tab("Basic Timeline Demo"):
+            # Timeline component
+            basic_timeline = VisTimeline(
+                value={
+                    "groups": [{"id": 0, "content": ""}],
+                    "items": []
+                },
+                options= {
+                    "start": day_offset(-1),
+                    "end": day_offset(20),
+                    "editable": True,
+                    "format": { # You don't need to define this as these are the default values, but for this demo it is necessary because of two timelines with different formats on one page
+                        "minorLabels": { 
+                            "millisecond": "SSS",
+                            "second": "ss",
+                            "minute": "HH:mm",
+                            "hour": "HH:mm",
+                        }
+                    }
+                },
+                label="Interactive Timeline",
+                interactive=True
+            )
+            
+            gr.Markdown("### Events")
+
+            # Event listener outputs
+            with gr.Row():
+                change_textbox = gr.Textbox(value="Most recent value change event:", label="Change:", lines=3, interactive=False)
+                input_textbox = gr.Textbox(value="Most recent user input event:", label="Input:", lines=3, interactive=False)
+                select_textbox = gr.Textbox(value="Most recent timeline selected event:", label="Select:", lines=3, interactive=False)
+                item_select_textbox = gr.Textbox(value="Currently selected item:\nNone", label="Currently selected item:", lines=3, interactive=False)
+            
+            # Examples and JSON area in two columns
+            with gr.Row():
+                # Left column: Examples
+                with gr.Column():
+                    gr.Markdown("### Timeline Examples")
+                    gr.Examples(
+                        examples=[
+                            {
+                                "groups": [{"id": 0, "content": ""}],
+                                "items": [
+                                    {"content": "Working", "group": 0, "start": day_offset(1), "end": day_offset(5)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(5), "end": day_offset(7)},
+                                    {"content": "Working", "group": 0, "start": day_offset(7), "end": day_offset(11)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(11), "end": day_offset(13)},
+                                    {"content": "Working", "group": 0, "start": day_offset(13), "end": day_offset(17)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(17), "end": day_offset(19)},
+                                    {"content": "Working", "group": 0, "start": day_offset(19), "end": day_offset(23)},
+                                ],
+                                "description": "DateTime ranges"
+                            },
+                            {
+                                "groups": [{"id": 0, "content": "Group"}],
+                                "items": [
+                                    {"id": 0, "content": "Simple item", "group": 0, "start": day_offset(9)}
+                                ]
+                            },
+                            {
+                                "groups": [{"id": 0, "content": "Worker 1"}, {"id": 1, "content": "Worker 2"}],
+                                "items": [
+                                    {"content": "Working", "group": 0, "start": day_offset(1), "end": day_offset(5)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(5), "end": day_offset(7)},
+                                    {"content": "Working", "group": 0, "start": day_offset(7), "end": day_offset(11)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(11), "end": day_offset(13)},
+                                    {"content": "Working", "group": 0, "start": day_offset(13), "end": day_offset(17)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(17), "end": day_offset(19)},
+                                    {"content": "Working", "group": 0, "start": day_offset(19), "end": day_offset(23)},
+                                    {"content": "Working", "group": 1, "start": day_offset(-3), "end": day_offset(2)},
+                                    {"content": "Resting", "group": 1, "start": day_offset(2), "end": day_offset(4)},
+                                    {"content": "Working", "group": 1, "start": day_offset(4), "end": day_offset(8)},
+                                    {"content": "Resting", "group": 1, "start": day_offset(8), "end": day_offset(10)},
+                                    {"content": "Working", "group": 1, "start": day_offset(10), "end": day_offset(14)},
+                                    {"content": "Resting", "group": 1, "start": day_offset(14), "end": day_offset(16)},
+                                    {"content": "Working", "group": 1, "start": day_offset(16), "end": day_offset(20)}
+                                ],
+                                "description": "DateTime ranges in groups"
+                            },
+                            {
+                                "groups": [{"id": 1, "content": "Group 1"}, {"id": 2, "content": "Group 2"}],
+                                "items": [
+                                    {"id": "A", "content": "Period A", "start": day_offset(1), "end": day_offset(7), "type": "background", "group": 1 },
+                                    {"id": "B", "content": "Period B", "start": day_offset(8), "end": day_offset(11), "type": "background", "group": 2 },
+                                    {"id": "C", "content": "Period C", "start": day_offset(12), "end": day_offset(17), "type": "background" },
+                                    {"content": "Range inside period A", "start": day_offset(2), "end": day_offset(6), "group": 1 },
+                                    {"content": "Item inside period C", "group": 2, "start": day_offset(14) }
+                                ],
+                                "description": "Background type example"
+                            },
+                            {
+                                "groups": [{"id": 1, "content": "Group 1"}, {"id": 2, "content": "Group 2"}],
+                                "items": [
+                                    {"content": "Range item", "group": 1, "start": day_offset(7), "end": day_offset(14) },
+                                    {"content": "Point item", "group": 2, "start": day_offset(7), "type": "point" },
+                                    {"content": "Point item with a longer name", "group": 2, "start": day_offset(7), "type": "point" },
+                                ],
+                                "description": "Point type example"
+                            },
+                            {
+                                "groups": [{"id": 1, "content": "Group 1", "subgroupStack": {"A": True, "B": True}}, {"id": 2, "content": "Group 2" }],
+                                "items": [
+                                    {"content": "Subgroup 2 Background", "start": day_offset(0), "end": day_offset(4), "type": "background", "group": 1, "subgroup": "A", "subgroupOrder": 0},
+                                    {"content": "Subgroup 2 Item", "start": day_offset(5), "end": day_offset(7), "group": 1, "subgroup": "A", "subgroupOrder": 0},
+                                    {"content": "Subgroup 1 Background", "start": day_offset(0), "end": day_offset(4), "type": "background", "group": 1, "subgroup": "B", "subgroupOrder": 1},
+                                    {"content": "Subgroup 1 Item", "start": day_offset(8), "end": day_offset(10), "group": 1, "subgroup": "B", "subgroupOrder": 1},
+                                    {"content": "Full group background", "start": day_offset(5), "end": day_offset(9), "type": "background", "group": 2},
+                                    {"content": "No subgroup item 1", "start": day_offset(10), "end": day_offset(12), "group": 2},
+                                    {"content": "No subgroup item 2", "start": day_offset(13), "end": day_offset(15), "group": 2}
+                                    
+                                ],
+                                "description": "Subgroups with backgrounds and items"
+                            },
+                            {
+                                "groups": [{"id": 1, "content": "Group 1", "subgroupStack": {"A": True, "B": True}}, {"id": 2, "content": "Group 2" }],
+                                "items": [
+                                    {"content": "Subgroup 2 background", "start": day_offset(0), "end": day_offset(4), "type": "background", "group": 1, "subgroup": "A", "subgroupOrder": 0},
+                                    {"content": "Subgroup 2 range", "start": day_offset(5), "end": day_offset(7), "group": 1, "subgroup": "A", "subgroupOrder": 0},
+                                    {"content": "Subgroup 2 item", "start": day_offset(10), "group": 1, "subgroup": "A" },
+                                    {"content": "Subgroup 1 background", "start": day_offset(0), "end": day_offset(4), "type": "background", "group": 1, "subgroup": "B", "subgroupOrder": 1},
+                                    {"content": "Subgroup 1 range", "start": day_offset(8), "end": day_offset(10), "group": 1, "subgroup": "B", "subgroupOrder": 1},
+                                    {"content": "Subgroup 1 item", "start": day_offset(14), "group": 1, "subgroup": "B" },
+                                    {"content": "No subgroup item", "start": day_offset(12), "group": 1},
+                                    {"content": "Full group background", "start": day_offset(5), "end": day_offset(9), "type": "background", "group": 2},
+                                    {"content": "No subgroup range 1", "start": day_offset(11), "end": day_offset(13), "group": 2},
+                                    {"content": "No subgroup range 2", "start": day_offset(15), "end": day_offset(17), "group": 2},
+                                    {"content": "No subgroup point", "start": day_offset(1), "group": 2, "type": "point" }
+                                    
+                                ],
+                                "description": "Combination of item and group types"
+                            }
+                        ],
+                        inputs=basic_timeline
+                    )
+                
+                # Right column: JSON staging area
+                with gr.Column():
+                    gr.Markdown("### Serialized Timeline Value")
+                    json_textbox = gr.Textbox(label="JSON", lines=4)
+                    with gr.Row():
+                        pull_button = gr.Button("Pull Timeline into JSON")
+                        push_button = gr.Button("Push JSON onto Timeline", variant="primary")
+            
+            # Event handlers
+            basic_timeline.change(fn=on_timeline_change, outputs=[change_textbox]) # Triggered when the value of the timeline changes by any means
+            basic_timeline.input(fn=on_timeline_input, outputs=[input_textbox]) # Triggered when the value of the timeline changes, caused directly by a user input on the component (dragging, adding & removing items)
+            basic_timeline.select(fn=on_timeline_select, outputs=[select_textbox]) # Triggered when the timeline is clicked
+            basic_timeline.item_select(fn=on_item_select, inputs=[basic_timeline], outputs=[item_select_textbox]) # Triggered when items are selected or unselected
+            
+            pull_button.click(fn=pull_from_timeline, inputs=[basic_timeline], outputs=[json_textbox]) # Example of using the timeline as an input
+            push_button.click(fn=push_to_timeline, inputs=[json_textbox], outputs=[basic_timeline]) # Example of using the timeline as an output
+        
+        # --- Tab 2: Timeline without date ---
+        with gr.Tab("Timeline Without Date"):
+            audio_output = gr.Audio(label="Generated Audio", type="numpy", elem_id=AUDIO_ID)
+
+            dateless_timeline = VisTimeline(
+                value={
+                    "groups": [{"id": "track-length", "content": ""}, {"id": 1, "content": ""}, {"id": 2, "content": ""}, {"id": 3, "content": ""}],
+                    "items": [
+                        {"content": "", "group": "track-length", "selectable": False, "type": "background", "start": 0, "end": 6000, "className": "color-primary-600"},
+                        {"id": 1, "content": "440.00Hz", "group": 1, "selectable": False, "start": 0, "end": 1500},
+                        {"id": 2, "content": "554.37Hz", "group": 2, "selectable": False, "start": 2000, "end": 3500},
+                        {"id": 3, "content": "659.26Hz", "group": 3, "selectable": False, "start": 4000, "end": 5500}
+                    ]},
+                options={
+                    "moment": "+00:00", # Force the timeline into a certain UTC offset timezone
+                    "showCurrentTime": False,
+                    "editable": {
+                        "add": False,
+                        "remove": False,
+                        "updateGroup": False,
+                        "updateTime": True
+                    },
+                    "itemsAlwaysDraggable": { # So dragging does not require selection first
+                        "item": True,
+                        "range": True
+                    },
+                    "showMajorLabels": False, # This hides the month & year labels
+                    "format": {
+                        "minorLabels": { # Force the minor labels into a format that does not include weekdays or months
+                            "millisecond": "mm:ss.SSS",
+                            "second": "mm:ss",
+                            "minute": "mm:ss",
+                            "hour": "HH:mm:ss"
+                        }
+                    },
+                    "start": 0,      # Timeline will start at unix epoch
+                    "end": 6000,     # Initial timeline range will end at 1 minute (unix timestamp in milliseconds)
+                    "min": 0,        # Restrict timeline navigation, timeline can not be scrolled further to the left than 0 seconds
+                    "max": 7000,     # Restrict timeline navigation, timeline can not be scrolled further to the right than 70 seconds
+                    "zoomMin": 1000, # Allow zoom in up until the entire timeline spans 1000 milliseconds
+                },
+                label="Timeline without date labels, with restrictions on navigation and zoom. You can drag and resize items without having to select them first.",
+                elem_id=TIMELINE_ID  # This will also make the timeline instance accessible in JavaScript via 'window.visTimelineInstances["your elem_id"]'
+            )
+            
+            table = gr.DataFrame(
+                headers=["Item Name", "Start Time", "Duration"],
+                label="Timeline Items",
+                interactive=False
+            )
+
+            generate_audio_button = gr.Button("Generate Audio")
+            
+            # Event handlers
+            dateless_timeline.change(fn=update_table, inputs=[dateless_timeline], outputs=[table])
+            dateless_timeline.load(fn=update_table, inputs=[dateless_timeline], outputs=[table])
+            generate_audio_button.click(fn=update_audio, inputs=[dateless_timeline], outputs=[audio_output])
+
+            generate_audio_button.click(
+                fn=update_audio, 
+                inputs=[dateless_timeline], 
+                outputs=[audio_output],
+            ).then(
+                fn=None,
+                inputs=None,
+                outputs=None,
+                js=f'() => initAudioSync("{TIMELINE_ID}", "{AUDIO_ID}", 6000)'
+            )
+        
+        # --- Tab 3: Links to documentation and examples ---
+        with gr.Tab("Documentation & More Examples"):
+            gr.Markdown("""
+                ## Vis.js Timeline Examples  
+                A collection of HTML/CSS/JavaScript snippets displaying various properties and use-cases:  
+                [https://visjs.github.io/vis-timeline/examples/timeline/](https://visjs.github.io/vis-timeline/examples/timeline/)
+                <br><br>
+                ## Vis.js Timeline Documentation  
+                The official documentation of the timeline:  
+                [https://visjs.github.io/vis-timeline/docs/timeline/](https://visjs.github.io/vis-timeline/docs/timeline/)
+                <br><br>
+                ## Vis.js DataSet Documentation  
+                The official documentation of the DataSet model:  
+                [https://visjs.github.io/vis-data/data/dataset.html](https://visjs.github.io/vis-data/data/dataset.html)
+            """)
+
+if __name__ == "__main__":
+    demo.launch(show_api=False)

custom_time_control.js

@@ -0,0 +1,121 @@
+function manageTimeBar(elemId, time) {
+    if (!window.visTimelineInstances) {
+        console.error(`Timeline instances collection not found`);
+        return;
+    }
+
+    const timeline = window.visTimelineInstances[elemId];
+    if (!timeline) {
+        console.error(`Timeline instance ${elemId} not found`);
+        return;
+    }
+    
+    if (!window.customTimeBarIds) {
+        window.customTimeBarIds = {};
+    }
+    
+    try {
+        timeline.setCustomTime(time, elemId);
+    } catch (e) {
+        timeline.addCustomTime(time, elemId);
+    }
+}
+
+function setTimeBarDirect(elemId, time) {
+    manageTimeBar(elemId, time);
+}
+
+function setTimeBarNormalized(elemId, start, end, normalizedPos) {
+    const time = start + (end - start) * normalizedPos;
+    manageTimeBar(elemId, time);
+}
+
+class AudioTimelineSync {
+    constructor(timelineId, audioId, trackLength) {
+        this.timelineId = timelineId;
+        this.trackLength = trackLength;
+        const container = document.getElementById(audioId);
+        
+        // Find the progress element through shadow DOM
+        const waveform = container.querySelector('#waveform');
+        if (!waveform) {
+            console.error('Waveform container not found');
+            return;
+        }
+
+        // Access shadow root and find progress element
+        const shadowRoot = waveform.querySelector('div').shadowRoot;
+        this.progressElement = shadowRoot.querySelector('div[part="progress"]');
+        
+        if (!this.progressElement) {
+            console.error('Progress element not found');
+            return;
+        }
+        
+        this.setupProgressObserver();
+    }
+    
+    setupProgressObserver() {
+        // Create mutation observer to watch for style changes to a specific progress element of the audio component
+        // The style is defined by the completion of the audio source, even when the audio is not playing but the time bar is being dragged by the cursor.
+        this.observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === 'attributes' && mutation.attributeName === 'style') {
+                    this.onProgressUpdate();
+                }
+            });
+        });
+        
+        // Observe the progress element for style changes
+        this.observer.observe(this.progressElement, {
+            attributes: true,
+            attributeFilter: ['style']
+        });
+    }
+    
+    onProgressUpdate() {
+        const style = this.progressElement.style;
+        const widthStr = style.width;
+        if (!widthStr) return;
+        
+        // Convert percentage string to number (e.g., "70.7421%" -> 0.707421)
+        const percentage = parseFloat(widthStr) / 100;
+        this.syncTimeBarToPlayback(percentage);
+    }
+    
+    syncTimeBarToPlayback(normalizedPosition) {
+        const timeline = window.visTimelineInstances[this.timelineId];
+        if (timeline) {
+            setTimeBarNormalized(this.timelineId, 0, this.trackLength, normalizedPosition);
+        }
+    }
+
+    cleanup() {
+        // Disconnect observer
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = null;
+        }
+    }
+}
+
+function initAudioSync(timelineId, audioId, trackLength) {
+    try {
+        // Initialize syncs container if it doesn't exist
+        if (!window.audioTimelineSyncs) {
+            window.audioTimelineSyncs = {};
+        }
+
+        // Cleanup existing sync if any
+        if (window.audioTimelineSyncs[timelineId]) {
+            window.audioTimelineSyncs[timelineId].cleanup();
+        }
+        
+        // Create new sync instance
+        window.audioTimelineSyncs[timelineId] = new AudioTimelineSync(timelineId, audioId, trackLength);
+    } catch (error) {
+        console.error('Error initializing audio sync:', error);
+    }
+
+    return null;
+}

requirements.txt

@@ -0,0 +1 @@
+gradio_vistimeline

src/.gitignore

@@ -0,0 +1,27 @@
+*.py[cod]
+__pycache__/
+*.so
+.Python
+.eggs/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.gradio/
+.gradio/certificate.pem
+
+node_modules/
+.svelte-kit/
+.vite/
+
+venv/
+.env/
+.venv/
+env/
+
+.vscode/
+.idea/
+*.swp
+*.swo
+
+.DS_Store

src/README.md

@@ -0,0 +1,193 @@
+---
+tags: [gradio-custom-component, timeline, vis timeline, vis-timeline, vis.js]
+title: gradio_vistimeline
+short_description: Gradio implementation for the vis.js Timeline library
+colorFrom: blue
+colorTo: yellow
+sdk: gradio
+pinned: false
+app_file: app.py
+---
+<h1 style='text-align: center; margin-bottom: 1rem'> Gradio vis.js Timeline </h1>
+
+<div style="display: flex; flex-direction: row; justify-content: center">
+<img style="display: block; padding-right: 5px; height: 20px;" alt="Static Badge" src="https://img.shields.io/pypi/v/gradio_vistimeline">
+<a href="https://github.com/Yelorix/gradio-vis-timeline" target="_blank"><img alt="Static Badge" src="https://img.shields.io/badge/github-white?logo=github&logoColor=black"></a>
+<a href="https://huggingface.co/spaces/Yelorix/gradio_vistimeline" target="_blank"><img alt="Open in Spaces" src="https://huggingface.co/datasets/huggingface/badges/resolve/main/open-in-hf-spaces-sm-dark.svg"></a>
+</div>
+
+A Gradio component that implements the [vis.js Timeline](https://github.com/visjs/vis-timeline) visualization library, allowing you to create interactive timelines in your Gradio apps.
+
+**Resources:**
+- [Timeline Examples](https://visjs.github.io/vis-timeline/examples/timeline/)
+- [Timeline Documentation](https://visjs.github.io/vis-timeline/docs/timeline/)
+- [Dataset Documentation](https://visjs.github.io/vis-data/data/dataset.html)
+
+## Installation
+
+```bash
+pip install gradio_vistimeline
+```
+
+## Usage
+
+```python
+import gradio as gr
+from gradio_vistimeline import VisTimeline
+
+demo = gr.Interface(
+    lambda x: x,
+    VisTimeline(
+        value={
+            "items": [
+                {"content": "Item 1", "start": "2024-12-2", "end": "2024-12-10"},
+                {"content": "Item 2", "start": "2024-12-14"}
+            ]
+        },
+        options={
+            "start": "2024-12-1",
+            "end": "2024-12-15",
+            "editable": True
+        }
+    ),
+    "json"
+)
+
+if __name__ == "__main__":
+    demo.launch()
+```
+
+## `VisTimeline`
+
+### Features
+
+- Interactive timeline visualization
+- Integration of vis.js Timeline includes:
+    - Items
+    - Ranges
+    - Points
+    - Background items
+    - Groups
+    - Subgroups
+- Pass options object during instantiation
+- Styled with the gradio style variables
+- Gradio events for editing data and selecting items
+
+### Value Data Format
+
+The timeline accepts a value in the following format:
+
+```python
+{
+    "groups": [
+        {
+            "id": "group_id", 
+            "content": "Group Name" # Optional
+        }
+    ],
+    "items": [
+        {
+            "content": "Item content",
+            "start": "2024-01-01",  # ISO date string or Unix timestamp
+            "end": "2024-01-05",    # Optional
+            "group": "group_id",    # Optional
+        }
+    ]
+}
+```
+
+Or as a VisTimelineData object:
+
+```python
+from gradio_vistimeline import VisTimelineGroup, VisTimelineItem, VisTimelineData
+
+value = VisTimelineData(
+    groups=[
+        VisTimelineGroup(
+            id="group_id", 
+            content="Group Name"   # Optional
+        )
+    ],
+    items=[
+        VisTimelineItem(
+            content="Item content",
+            start="2024-01-01",    # ISO date string or Unix timestamp
+            end="2024-01-05",      # Optional
+            group="group_id"       # Optional
+        )
+    ]
+)
+```
+
+### Events
+
+| name | description |
+|:-----|:------------|
+| `load` | Triggered when the component is mounted for the first time |
+| `change` | Triggered when the timeline value changes through any means |
+| `input` | Triggered when a user directly modifies timeline items (add/remove/update) |
+| `select` | Triggered when clicking the timeline |
+| `item_select` | Triggered when items are selected or unselected |
+
+### Configuration
+
+#### vis.js Timeline Options
+
+The component accepts all configuration options supported by vis.js Timeline. Some commonly used options:
+
+```python
+options = {
+    "editable": True,             # Enable item editing
+    "multiselect": True,          # Allow selecting multiple items
+    "showCurrentTime": True,      # Show a marker for current time
+    "stack": True,                # Stack overlapping items
+    "zoomable": True              # Allow zooming the timeline
+}
+```
+
+For a complete list of options, see the [vis.js Timeline documentation](https://visjs.github.io/vis-timeline/docs/timeline/).
+
+#### Component-Specific Options
+
+**Data Synchronization**
+```python
+VisTimeline(
+    value=value,
+    preserve_old_content_on_value_change=True  # Default: False
+)
+```
+Controls how the timeline updates their groups and items DataSets when the component value changes:
+- `False`: Clears and reinitializes all DataSets to ensure perfect sync with the Gradio component value
+- `True`: Merges new data with existing content (updates existing items, adds new ones, removes missing ones)
+
+Defaulted to false to ensure the value matches the visualization on the timeline.
+
+Changing it to true reduces visual flicker when dragging items around. 
+Desync is only a real risk in this mode when you edit item ID's or add/remove item properties of existing items.
+
+**JavaScript Integration**
+```python
+VisTimeline(
+    value=value,
+    elem_id="my-timeline"  # Optional
+)
+```
+When `elem_id` is set, the timeline instance becomes available in JavaScript as `window.visTimelineInstances["my-timeline"]`, allowing easy access through custom scripts.
+
+**Styling Items**
+The component provides pre-defined color classes matching Gradio's theme colors. Apply them by setting an item's `className`:
+
+```python
+item = {
+    "content": "Colored item",
+    "start": "2024-01-01",
+    "className": "color-primary-500"  # Uses Gradio's primary-500 color
+}
+```
+
+Available color classes follow the pattern:
+- `color-primary-[50-950]`
+- `color-secondary-[50-950]`
+- `color-neutral-[50-950]`
+
+Custom styles can be applied by defining your own CSS classes.

src/backend/gradio_vistimeline/__init__.py

@@ -0,0 +1,5 @@
+
+from .vistimeline import VisTimeline
+from .model import VisTimelineData, VisTimelineItem, VisTimelineGroup
+
+__all__ = ['VisTimeline', 'VisTimelineGroup', 'VisTimelineItem', 'VisTimelineData']

src/backend/gradio_vistimeline/model.py

@@ -0,0 +1,35 @@
+from typing import Any, Callable, Optional, List, Union
+from gradio.data_classes import GradioModel
+
+class VisTimelineGroup(GradioModel):
+    id: Union[str, int]
+    content: str
+    className: Optional[str] = None
+    style: Optional[str] = None
+    order: Optional[Union[str, int]] = None
+    subgroupOrder: Optional[Union[str, Callable]] = None
+    subgroupStack: Optional[Union[bool, dict]] = None
+    subgroupVisibility: Optional[dict] = None
+    title: Optional[str] = None
+    visible: Optional[bool] = None
+    nestedGroups: Optional[List[Union[str, int]]] = None
+    showNested: Optional[bool] = None
+
+class VisTimelineItem(GradioModel):
+    id: Optional[Union[str, int]] = None
+    content: str
+    start: str
+    end: Optional[str] = None
+    group: Optional[Union[str, int]] = None
+    className: Optional[str] = None
+    align: Optional[str] = None
+    style: Optional[str] = None
+    title: Optional[str] = None
+    type: Optional[str] = None  # 'box', 'point', 'range', or 'background'
+    selectable: Optional[bool] = None
+    limitSize: Optional[bool] = None
+    subgroup: Optional[Union[str, int]] = None
+
+class VisTimelineData(GradioModel):
+    groups: List[Union[VisTimelineGroup, dict[str, Any]]]
+    items: List[Union[VisTimelineItem, dict[str, Any]]]

src/backend/gradio_vistimeline/templates/example/index.js

@@ -0,0 +1,151 @@
+const {
+  SvelteComponent: M,
+  append_hydration: w,
+  attr: S,
+  children: k,
+  claim_element: T,
+  claim_text: I,
+  detach: _,
+  element: x,
+  init: L,
+  insert_hydration: R,
+  noop: C,
+  safe_not_equal: U,
+  set_data: V,
+  text: q,
+  toggle_class: d
+} = window.__gradio__svelte__internal;
+function j(i) {
+  let e, t, a = E(
+    /*value*/
+    i[0]
+  ) + "", l;
+  return {
+    c() {
+      e = x("div"), t = x("div"), l = q(a), this.h();
+    },
+    l(c) {
+      e = T(c, "DIV", { class: !0 });
+      var u = k(e);
+      t = T(u, "DIV", { class: !0 });
+      var s = k(t);
+      l = I(s, a), s.forEach(_), u.forEach(_), this.h();
+    },
+    h() {
+      S(t, "class", "example-content svelte-1rustph"), S(e, "class", "example-container svelte-1rustph"), d(
+        e,
+        "table",
+        /*type*/
+        i[1] === "table"
+      ), d(
+        e,
+        "gallery",
+        /*type*/
+        i[1] === "gallery"
+      ), d(
+        e,
+        "selected",
+        /*selected*/
+        i[2]
+      );
+    },
+    m(c, u) {
+      R(c, e, u), w(e, t), w(t, l);
+    },
+    p(c, [u]) {
+      u & /*value*/
+      1 && a !== (a = E(
+        /*value*/
+        c[0]
+      ) + "") && V(l, a), u & /*type*/
+      2 && d(
+        e,
+        "table",
+        /*type*/
+        c[1] === "table"
+      ), u & /*type*/
+      2 && d(
+        e,
+        "gallery",
+        /*type*/
+        c[1] === "gallery"
+      ), u & /*selected*/
+      4 && d(
+        e,
+        "selected",
+        /*selected*/
+        c[2]
+      );
+    },
+    i: C,
+    o: C,
+    d(c) {
+      c && _(e);
+    }
+  };
+}
+function E(i) {
+  const e = i.items.length, t = i.groups.length, a = z(i.items);
+  return `${i.description ? i.description : `${e} item${e !== 1 ? "s" : ""} in ${t} group${t !== 1 ? "s" : ""}`}
+${a}`;
+}
+function z(i) {
+  if (i.length === 0) return "";
+  const e = i.flatMap((l) => [new Date(l.start), l.end ? new Date(l.end) : null]).filter((l) => l !== null), t = new Date(Math.min(...e.map((l) => l.getTime()))), a = new Date(Math.max(...e.map((l) => l.getTime())));
+  return t.getTime() === a.getTime() ? f(t, !0) : `${f(t)} - ${f(a)}`;
+}
+function f(i, e = !1) {
+  return e ? i.toLocaleDateString("en-US", {
+    month: "long",
+    day: "numeric",
+    year: "numeric"
+  }) : i.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+function A(i, e, t) {
+  let { value: a } = e, { type: l } = e, { selected: c = !1 } = e, { options: u = void 0 } = e, { preserve_old_content_on_value_change: s = void 0 } = e, { label: m = void 0 } = e, { interactive: r = void 0 } = e, { visible: o = void 0 } = e, { elem_id: g = void 0 } = e, { elem_classes: h = void 0 } = e, { key: v = void 0 } = e, { samples_dir: y = void 0 } = e, { index: b = void 0 } = e, { root: D = void 0 } = e;
+  return i.$$set = (n) => {
+    "value" in n && t(0, a = n.value), "type" in n && t(1, l = n.type), "selected" in n && t(2, c = n.selected), "options" in n && t(3, u = n.options), "preserve_old_content_on_value_change" in n && t(4, s = n.preserve_old_content_on_value_change), "label" in n && t(5, m = n.label), "interactive" in n && t(6, r = n.interactive), "visible" in n && t(7, o = n.visible), "elem_id" in n && t(8, g = n.elem_id), "elem_classes" in n && t(9, h = n.elem_classes), "key" in n && t(10, v = n.key), "samples_dir" in n && t(11, y = n.samples_dir), "index" in n && t(12, b = n.index), "root" in n && t(13, D = n.root);
+  }, [
+    a,
+    l,
+    c,
+    u,
+    s,
+    m,
+    r,
+    o,
+    g,
+    h,
+    v,
+    y,
+    b,
+    D
+  ];
+}
+class B extends M {
+  constructor(e) {
+    super(), L(this, e, A, j, U, {
+      value: 0,
+      type: 1,
+      selected: 2,
+      options: 3,
+      preserve_old_content_on_value_change: 4,
+      label: 5,
+      interactive: 6,
+      visible: 7,
+      elem_id: 8,
+      elem_classes: 9,
+      key: 10,
+      samples_dir: 11,
+      index: 12,
+      root: 13
+    });
+  }
+}
+export {
+  B as default
+};

src/backend/gradio_vistimeline/templates/example/style.css

@@ -0,0 +1 @@
+.example-container.svelte-1rustph{border:var(--button-border-width) solid var(--button-secondary-border-color)!important;background:var(--button-secondary-background-fill)!important;color:var(--button-secondary-text-color)!important;border-radius:var(--button-large-radius)!important;transition:all .2s ease;cursor:pointer;overflow:hidden}.example-content.svelte-1rustph{padding:var(--spacing-md);font-size:var(--text-sm);white-space:pre-line;line-height:1.4}.selected.svelte-1rustph{border:var(--button-border-width) solid var(--button-secondary-border-color-hover)!important;background:var(--button-secondary-background-fill-hover)!important;color:var(--button-secondary-text-color-hover)!important;border-radius:var(--button-large-radius)!important}.gallery.svelte-1rustph{min-width:100px}

src/backend/gradio_vistimeline/vistimeline.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+from typing import Any, Callable, Union
+from gradio.components import Component
+from gradio.events import Events
+from .model import VisTimelineData
+
+class VisTimeline(Component):
+    """
+    Custom Gradio component integrating vis.js Timeline.
+    """
+    data_model = VisTimelineData
+    EVENTS = [Events.load, Events.change, Events.input, "item_select", Events.select]
+
+    def __init__(
+        self,
+        value: Union[VisTimelineData, dict[str, Any], Callable, None] = None,
+        options: dict[str, Any] | None = None,
+        preserve_old_content_on_value_change: bool = False,
+        *,
+        label: str | None = None,
+        interactive: bool | None = True,
+        visible: bool = True,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+        key: int | str | None = None,
+    ):
+        self.value = self._get_default_value_if_none(value)
+        self.options = options or {}
+        self.preserve_old_content_on_value_change = preserve_old_content_on_value_change
+
+        super().__init__(
+            value=self.value,
+            label=label,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+            key=key
+        )
+
+    def preprocess(self, payload: Union[VisTimelineData, dict[str, Any], None]) -> Union[VisTimelineData, dict[str, Any], None]:
+        return self._get_default_value_if_none(payload)
+
+    def postprocess(self, value: Union[VisTimelineData, dict[str, Any], None]) -> Union[VisTimelineData, dict[str, Any], None]:
+        def remove_first_level_none_properties(obj):
+            return {key: value for key, value in obj.items() if value is not None}
+
+        value = self._get_default_value_if_none(value)
+
+        if isinstance(value, VisTimelineData):
+            value.groups = [remove_first_level_none_properties(vars(group)) for group in value.groups]
+            value.items = [remove_first_level_none_properties(vars(item)) for item in value.items]
+        elif isinstance(value, dict):
+            value["groups"] = [remove_first_level_none_properties(group) for group in value.get("groups", [])]
+            value["items"] = [remove_first_level_none_properties(item) for item in value.get("items", [])]
+
+        return value
+
+    def example_payload(self) -> Any:
+        return {
+            "groups": [{"id": 0, "content": "Group 1"}],
+            "items": [{"content": "Item 1", "group": 0, "start": "2024-01-01"}]
+        }
+
+    def example_value(self) -> dict[str, Any]:
+        return self.example_payload()
+    
+    def _get_default_value_if_none(self, value):
+        if isinstance(value, VisTimelineData):
+            return value or VisTimelineData(groups=[], items=[])
+        else:
+            return value or {"groups": [], "items": []}

src/backend/gradio_vistimeline/vistimeline.pyi

@@ -0,0 +1,305 @@
+from __future__ import annotations
+from typing import Any, Callable, Union
+from gradio.components import Component
+from gradio.events import Events
+from .model import VisTimelineData
+from gradio.events import Dependency
+
+class VisTimeline(Component):
+    """
+    Custom Gradio component integrating vis.js Timeline.
+    """
+    data_model = VisTimelineData
+    EVENTS = [Events.load, Events.change, Events.input, "item_select", Events.select]
+
+    def __init__(
+        self,
+        value: Union[VisTimelineData, dict[str, Any], Callable, None] = None,
+        options: dict[str, Any] | None = None,
+        preserve_old_content_on_value_change: bool = False,
+        *,
+        label: str | None = None,
+        interactive: bool | None = True,
+        visible: bool = True,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+        key: int | str | None = None,
+    ):
+        self.value = self._get_default_value_if_none(value)
+        self.options = options or {}
+        self.preserve_old_content_on_value_change = preserve_old_content_on_value_change
+
+        super().__init__(
+            value=self.value,
+            label=label,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+            key=key
+        )
+
+    def preprocess(self, payload: Union[VisTimelineData, dict[str, Any], None]) -> Union[VisTimelineData, dict[str, Any], None]:
+        return self._get_default_value_if_none(payload)
+
+    def postprocess(self, value: Union[VisTimelineData, dict[str, Any], None]) -> Union[VisTimelineData, dict[str, Any], None]:
+        def remove_first_level_none_properties(obj):
+            return {key: value for key, value in obj.items() if value is not None}
+
+        value = self._get_default_value_if_none(value)
+
+        if isinstance(value, VisTimelineData):
+            value.groups = [remove_first_level_none_properties(vars(group)) for group in value.groups]
+            value.items = [remove_first_level_none_properties(vars(item)) for item in value.items]
+        elif isinstance(value, dict):
+            value["groups"] = [remove_first_level_none_properties(group) for group in value.get("groups", [])]
+            value["items"] = [remove_first_level_none_properties(item) for item in value.get("items", [])]
+
+        return value
+
+    def example_payload(self) -> Any:
+        return {
+            "groups": [{"id": 0, "content": "Group 1"}],
+            "items": [{"content": "Item 1", "group": 0, "start": "2024-01-01"}]
+        }
+
+    def example_value(self) -> dict[str, Any]:
+        return self.example_payload()
+    
+    def _get_default_value_if_none(self, value):
+        if isinstance(value, VisTimelineData):
+            return value or VisTimelineData(groups=[], items=[])
+        else:
+            return value or {"groups": [], "items": []}
+    from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+    from gradio.blocks import Block
+    if TYPE_CHECKING:
+        from gradio.components import Timer
+
+    
+    def load(self,
+        fn: Callable[..., Any] | None = None,
+        inputs: Block | Sequence[Block] | set[Block] | None = None,
+        outputs: Block | Sequence[Block] | None = None,
+        api_name: str | None | Literal[False] = None,
+        scroll_to_output: bool = False,
+        show_progress: Literal["full", "minimal", "hidden"] = "full",
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+        every: Timer | float | None = None,
+        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+        js: str | None = None,
+        concurrency_limit: int | None | Literal["default"] = "default",
+        concurrency_id: str | None = None,
+        show_api: bool = True,
+    
+        ) -> Dependency:
+        """
+        Parameters:
+            fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+            outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+            api_name: defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
+            scroll_to_output: if True, will scroll to output component on completion
+            show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+            queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+            batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+            every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+            trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+            js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+            concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+            concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+            show_api: whether to show this event in the "view API" page of the Gradio app, or in the ".view_api()" method of the Gradio clients. Unlike setting api_name to False, setting show_api to False will still allow downstream apps as well as the Clients to use this event. If fn is None, show_api will automatically be set to False.
+        
+        """
+        ...
+    
+    def change(self,
+        fn: Callable[..., Any] | None = None,
+        inputs: Block | Sequence[Block] | set[Block] | None = None,
+        outputs: Block | Sequence[Block] | None = None,
+        api_name: str | None | Literal[False] = None,
+        scroll_to_output: bool = False,
+        show_progress: Literal["full", "minimal", "hidden"] = "full",
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+        every: Timer | float | None = None,
+        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+        js: str | None = None,
+        concurrency_limit: int | None | Literal["default"] = "default",
+        concurrency_id: str | None = None,
+        show_api: bool = True,
+    
+        ) -> Dependency:
+        """
+        Parameters:
+            fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+            outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+            api_name: defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
+            scroll_to_output: if True, will scroll to output component on completion
+            show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+            queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+            batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+            every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+            trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+            js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+            concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+            concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+            show_api: whether to show this event in the "view API" page of the Gradio app, or in the ".view_api()" method of the Gradio clients. Unlike setting api_name to False, setting show_api to False will still allow downstream apps as well as the Clients to use this event. If fn is None, show_api will automatically be set to False.
+        
+        """
+        ...
+    
+    def input(self,
+        fn: Callable[..., Any] | None = None,
+        inputs: Block | Sequence[Block] | set[Block] | None = None,
+        outputs: Block | Sequence[Block] | None = None,
+        api_name: str | None | Literal[False] = None,
+        scroll_to_output: bool = False,
+        show_progress: Literal["full", "minimal", "hidden"] = "full",
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+        every: Timer | float | None = None,
+        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+        js: str | None = None,
+        concurrency_limit: int | None | Literal["default"] = "default",
+        concurrency_id: str | None = None,
+        show_api: bool = True,
+    
+        ) -> Dependency:
+        """
+        Parameters:
+            fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+            outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+            api_name: defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
+            scroll_to_output: if True, will scroll to output component on completion
+            show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+            queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+            batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+            every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+            trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+            js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+            concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+            concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+            show_api: whether to show this event in the "view API" page of the Gradio app, or in the ".view_api()" method of the Gradio clients. Unlike setting api_name to False, setting show_api to False will still allow downstream apps as well as the Clients to use this event. If fn is None, show_api will automatically be set to False.
+        
+        """
+        ...
+    
+    def item_select(self,
+        fn: Callable[..., Any] | None = None,
+        inputs: Block | Sequence[Block] | set[Block] | None = None,
+        outputs: Block | Sequence[Block] | None = None,
+        api_name: str | None | Literal[False] = None,
+        scroll_to_output: bool = False,
+        show_progress: Literal["full", "minimal", "hidden"] = "full",
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+        every: Timer | float | None = None,
+        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+        js: str | None = None,
+        concurrency_limit: int | None | Literal["default"] = "default",
+        concurrency_id: str | None = None,
+        show_api: bool = True,
+    
+        ) -> Dependency:
+        """
+        Parameters:
+            fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+            outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+            api_name: defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
+            scroll_to_output: if True, will scroll to output component on completion
+            show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+            queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+            batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+            every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+            trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+            js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+            concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+            concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+            show_api: whether to show this event in the "view API" page of the Gradio app, or in the ".view_api()" method of the Gradio clients. Unlike setting api_name to False, setting show_api to False will still allow downstream apps as well as the Clients to use this event. If fn is None, show_api will automatically be set to False.
+        
+        """
+        ...
+    
+    def select(self,
+        fn: Callable[..., Any] | None = None,
+        inputs: Block | Sequence[Block] | set[Block] | None = None,
+        outputs: Block | Sequence[Block] | None = None,
+        api_name: str | None | Literal[False] = None,
+        scroll_to_output: bool = False,
+        show_progress: Literal["full", "minimal", "hidden"] = "full",
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+        every: Timer | float | None = None,
+        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+        js: str | None = None,
+        concurrency_limit: int | None | Literal["default"] = "default",
+        concurrency_id: str | None = None,
+        show_api: bool = True,
+    
+        ) -> Dependency:
+        """
+        Parameters:
+            fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+            outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+            api_name: defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
+            scroll_to_output: if True, will scroll to output component on completion
+            show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+            queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+            batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+            every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+            trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+            js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+            concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+            concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+            show_api: whether to show this event in the "view API" page of the Gradio app, or in the ".view_api()" method of the Gradio clients. Unlike setting api_name to False, setting show_api to False will still allow downstream apps as well as the Clients to use this event. If fn is None, show_api will automatically be set to False.
+        
+        """
+        ...

src/demo/app.py

@@ -0,0 +1,475 @@
+import datetime as dt
+import gradio as gr
+import json
+import numpy as np
+import os
+from datetime import timedelta, date, datetime
+from gradio_vistimeline import VisTimeline, VisTimelineData
+
+# --- Region: Handlers for demo tab 1 ---
+def pull_from_timeline(timeline):
+    """Convert timeline data to JSON string for display"""
+    if hasattr(timeline, "model_dump"):
+        data = timeline.model_dump(exclude_none=True)
+    else:
+        data = timeline
+    return json.dumps(data, indent=2)
+
+def push_to_timeline(json_str):
+    """Convert JSON string to timeline data"""
+    try:
+        return VisTimelineData.model_validate_json(json_str)
+    except Exception as e:
+        print(f"Error parsing JSON: {e}")
+        return VisTimelineData(groups=[], items=[])
+
+def on_timeline_change():
+    return f"Most recent value change event:\n{get_now()}"
+
+def on_timeline_input(event_data: gr.EventData):
+    return f"Most recent input event:\nAction: '{event_data._data}' at {get_now()}"
+
+def on_timeline_select():
+    return f"Most recent timeline selected event::\n{get_now()}"
+
+def on_item_select(timeline, event_data: gr.EventData):
+    selected_ids = event_data._data # A collection of selected item IDs that can be str or int: ["example", 0, "example2"]
+    items = timeline.items
+
+    if selected_ids:
+        first_id = selected_ids[0]
+        for item in items:
+            if item.id == first_id:
+                content = getattr(item, 'content', 'Unknown')
+                return f"Currently selected item:\nContent: \"{content}\"\nID: \"{first_id}\""
+    
+    return "Currently selected item:\nNone"
+
+# --- Region: Handlers for demo tab 1 ---
+def update_table(timeline):
+    if hasattr(timeline, "model_dump"):
+        data = timeline.model_dump(exclude_none=True)
+    else:
+        data = timeline
+    
+    items = data["items"]
+    track_length_ms = get_grouped_item_end_in_ms(items, "track-length")
+
+    rows = []
+    for item in items:
+        if item["content"] != "":
+            duration = calculate_and_format_duration(item["start"], item.get("end"), track_length_ms)
+            rows.append([
+                item["content"],
+                format_date_to_milliseconds(item["start"]),
+                duration
+            ])
+    
+    return gr.DataFrame(
+        value=rows,
+        headers=["Item Name", "Start Time", "Duration"]
+    )
+
+# --- Region: Handlers for demo tab 2 ---
+def update_audio(timeline):
+    """
+    Handler function for generating audio from timeline data.
+    Returns audio data in format expected by Gradio's Audio component.
+    """
+    audio_data, sample_rate = generate_audio_from_timeline(timeline)
+    # Convert to correct shape and data type for Gradio Audio
+    # Gradio expects a 2D array with shape (samples, channels)
+    audio_data = audio_data.reshape(-1, 1)  # Make it 2D with 1 channel
+    return (sample_rate, audio_data)
+
+def generate_audio_from_timeline(timeline_data, sample_rate=44100):
+    """
+    Generate audio from timeline items containing frequency information.
+    
+    Args:
+        timeline_data: Timeline data containing items with start/end times in milliseconds
+        sample_rate: Audio sample rate in Hz (default 44100)
+        
+    Returns:
+        Tuple of (audio_data: np.ndarray, sample_rate: int)
+    """
+    # Get all items from the timeline
+    if hasattr(timeline_data, "model_dump"):
+        data = timeline_data.model_dump(exclude_none=True)
+    else:
+        data = timeline_data
+    
+    items = data["items"]
+    
+    # Find the track length from the background item
+    track_length_ms = get_grouped_item_end_in_ms(items, "track-length")
+    
+    # Convert milliseconds to samples
+    total_samples = int((track_length_ms / 1000) * sample_rate)
+    
+    # Initialize empty audio buffer
+    audio_buffer = np.zeros(total_samples)
+    
+    # Frequency mapping
+    freq_map = {
+        1: 440.0,
+        2: 554.37,
+        3: 659.26
+    }
+    # Generate sine waves for each item
+    for item in items:
+        id = item.get("id", 0)
+        start_time = parse_date_to_milliseconds(item["start"])
+        end_time = parse_date_to_milliseconds(item["end"])
+
+        # Skip items that are completely outside the valid range
+        if end_time <= 0 or start_time >= track_length_ms or start_time >= end_time:
+            continue
+            
+        # Clamp times to valid range
+        start_time = max(0, min(start_time, track_length_ms))
+        end_time = max(0, min(end_time, track_length_ms))
+
+        if id in freq_map:
+            freq = freq_map[id]
+            
+            # Convert millisecond timestamps to sample indices
+            start_sample = int((start_time / 1000) * sample_rate)
+            end_sample = int((end_time / 1000) * sample_rate)
+            
+            # Generate time array for this segment
+            t = np.arange(start_sample, end_sample)
+            
+            # Generate sine wave
+            duration = end_sample - start_sample
+            envelope = np.ones(duration)
+            fade_samples = min(int(0.10 * sample_rate), duration // 2)  # 100ms fade or half duration
+            envelope[:fade_samples] = np.linspace(0, 1, fade_samples)
+            envelope[-fade_samples:] = np.linspace(1, 0, fade_samples)
+            
+            wave = 0.2 * envelope * np.sin(2 * np.pi * freq * t / sample_rate)
+            
+            # Add to buffer
+            audio_buffer[start_sample:end_sample] += wave
+    
+    # Normalize to prevent clipping
+    max_val = np.max(np.abs(audio_buffer))
+    if max_val > 0:
+        audio_buffer = audio_buffer / max_val
+    
+    return (audio_buffer, sample_rate)
+
+# Helper function to get hard-coded track-length from timeline value
+def get_grouped_item_end_in_ms(items, group_id):
+    default_length = 6000
+    for item in items:
+        if item.get("group") == group_id:
+            return parse_date_to_milliseconds(item.get("end", default_length))
+    return default_length
+
+# --- Region: Demo specific datetime helper functions ---
+def calculate_and_format_duration(start_date, end_date, max_range):
+    """Calculate the seconds between two datetime inputs and format the result with up to 2 decimals."""
+    if not end_date:
+        return "0s"
+
+    # Convert dates to milliseconds
+    start_ms = max(0, parse_date_to_milliseconds(start_date))
+    end_ms = min(max_range, parse_date_to_milliseconds(end_date))
+
+    if end_ms < start_ms:
+        return "0s"
+
+    # Calculate duration in seconds
+    duration = (end_ms - start_ms) / 1000
+
+    # Format to remove trailing zeroes after rounding to 2 decimal places
+    formatted_duration = f"{duration:.2f}".rstrip("0").rstrip(".")
+    return f"{formatted_duration}s"
+
+def format_date_to_milliseconds(date):
+    """Format input (ISO8601 string or milliseconds) to mm:ss.SSS."""
+    date_in_milliseconds = max(0, parse_date_to_milliseconds(date))
+    time = timedelta(milliseconds=date_in_milliseconds)
+
+    # Format timedelta into mm:ss.SSS
+    minutes, seconds = divmod(time.seconds, 60)
+    milliseconds_part = time.microseconds // 1000
+    return f"{minutes:02}:{seconds:02}.{milliseconds_part:03}"
+
+def parse_date_to_milliseconds(date):
+    """Convert input (ISO8601 string or milliseconds) milliseconds"""
+    if isinstance(date, int):  # Input is already in milliseconds (Unix timestamp)
+        return date
+    elif isinstance(date, str):  # Input is ISO8601 datetime string
+        dt = datetime.fromisoformat(date.replace("Z", "+00:00"))
+        epoch = datetime(1970, 1, 1, tzinfo=dt.tzinfo) # Calculate difference from Unix epoch
+        return int((dt - epoch).total_seconds() * 1000)
+    else:
+        return 0  # Fallback for unsupported types
+
+def get_now():
+    """Returns current time in HH:MM:SS format"""
+    return datetime.now().strftime("%H:%M:%S")
+
+TIMELINE_ID = "dateless_timeline"
+AUDIO_ID = "timeline-audio"
+
+# Example for how to access the timeline through JavaScript
+# In this case, to bind the custom time bar of the timeline to be in sync with the audio component
+# Read the JavaScript file
+js_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'custom_time_control.js')
+with open(js_path, 'r') as f:
+    js_content = f.read()
+script = f"""<script>{js_content}</script>"""
+style = f"""<style>.vis-custom-time.{TIMELINE_ID} {{pointer-events: none !important;}}</style>"""
+head = script + style
+
+# --- Region: Gradio ---
+with gr.Blocks(head=head) as demo:
+    today = date.today()
+    day_offset = lambda days: (today + dt.timedelta(days=days)).isoformat()
+
+    gr.Markdown("# Vis.js Timeline Component Demo")
+    
+    with gr.Tabs():
+        # --- Tab 1: Basic Timeline with Events ---
+        with gr.Tab("Basic Timeline Demo"):
+            # Timeline component
+            basic_timeline = VisTimeline(
+                value={
+                    "groups": [{"id": 0, "content": ""}],
+                    "items": []
+                },
+                options= {
+                    "start": day_offset(-1),
+                    "end": day_offset(20),
+                    "editable": True,
+                    "format": { # You don't need to define this as these are the default values, but for this demo it is necessary because of two timelines with different formats on one page
+                        "minorLabels": { 
+                            "millisecond": "SSS",
+                            "second": "ss",
+                            "minute": "HH:mm",
+                            "hour": "HH:mm",
+                        }
+                    }
+                },
+                label="Interactive Timeline",
+                interactive=True
+            )
+            
+            gr.Markdown("### Events")
+
+            # Event listener outputs
+            with gr.Row():
+                change_textbox = gr.Textbox(value="Most recent value change event:", label="Change:", lines=3, interactive=False)
+                input_textbox = gr.Textbox(value="Most recent user input event:", label="Input:", lines=3, interactive=False)
+                select_textbox = gr.Textbox(value="Most recent timeline selected event:", label="Select:", lines=3, interactive=False)
+                item_select_textbox = gr.Textbox(value="Currently selected item:\nNone", label="Currently selected item:", lines=3, interactive=False)
+            
+            # Examples and JSON area in two columns
+            with gr.Row():
+                # Left column: Examples
+                with gr.Column():
+                    gr.Markdown("### Timeline Examples")
+                    gr.Examples(
+                        examples=[
+                            {
+                                "groups": [{"id": 0, "content": ""}],
+                                "items": [
+                                    {"content": "Working", "group": 0, "start": day_offset(1), "end": day_offset(5)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(5), "end": day_offset(7)},
+                                    {"content": "Working", "group": 0, "start": day_offset(7), "end": day_offset(11)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(11), "end": day_offset(13)},
+                                    {"content": "Working", "group": 0, "start": day_offset(13), "end": day_offset(17)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(17), "end": day_offset(19)},
+                                    {"content": "Working", "group": 0, "start": day_offset(19), "end": day_offset(23)},
+                                ],
+                                "description": "DateTime ranges"
+                            },
+                            {
+                                "groups": [{"id": 0, "content": "Group"}],
+                                "items": [
+                                    {"id": 0, "content": "Simple item", "group": 0, "start": day_offset(9)}
+                                ]
+                            },
+                            {
+                                "groups": [{"id": 0, "content": "Worker 1"}, {"id": 1, "content": "Worker 2"}],
+                                "items": [
+                                    {"content": "Working", "group": 0, "start": day_offset(1), "end": day_offset(5)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(5), "end": day_offset(7)},
+                                    {"content": "Working", "group": 0, "start": day_offset(7), "end": day_offset(11)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(11), "end": day_offset(13)},
+                                    {"content": "Working", "group": 0, "start": day_offset(13), "end": day_offset(17)},
+                                    {"content": "Resting", "group": 0, "start": day_offset(17), "end": day_offset(19)},
+                                    {"content": "Working", "group": 0, "start": day_offset(19), "end": day_offset(23)},
+                                    {"content": "Working", "group": 1, "start": day_offset(-3), "end": day_offset(2)},
+                                    {"content": "Resting", "group": 1, "start": day_offset(2), "end": day_offset(4)},
+                                    {"content": "Working", "group": 1, "start": day_offset(4), "end": day_offset(8)},
+                                    {"content": "Resting", "group": 1, "start": day_offset(8), "end": day_offset(10)},
+                                    {"content": "Working", "group": 1, "start": day_offset(10), "end": day_offset(14)},
+                                    {"content": "Resting", "group": 1, "start": day_offset(14), "end": day_offset(16)},
+                                    {"content": "Working", "group": 1, "start": day_offset(16), "end": day_offset(20)}
+                                ],
+                                "description": "DateTime ranges in groups"
+                            },
+                            {
+                                "groups": [{"id": 1, "content": "Group 1"}, {"id": 2, "content": "Group 2"}],
+                                "items": [
+                                    {"id": "A", "content": "Period A", "start": day_offset(1), "end": day_offset(7), "type": "background", "group": 1 },
+                                    {"id": "B", "content": "Period B", "start": day_offset(8), "end": day_offset(11), "type": "background", "group": 2 },
+                                    {"id": "C", "content": "Period C", "start": day_offset(12), "end": day_offset(17), "type": "background" },
+                                    {"content": "Range inside period A", "start": day_offset(2), "end": day_offset(6), "group": 1 },
+                                    {"content": "Item inside period C", "group": 2, "start": day_offset(14) }
+                                ],
+                                "description": "Background type example"
+                            },
+                            {
+                                "groups": [{"id": 1, "content": "Group 1"}, {"id": 2, "content": "Group 2"}],
+                                "items": [
+                                    {"content": "Range item", "group": 1, "start": day_offset(7), "end": day_offset(14) },
+                                    {"content": "Point item", "group": 2, "start": day_offset(7), "type": "point" },
+                                    {"content": "Point item with a longer name", "group": 2, "start": day_offset(7), "type": "point" },
+                                ],
+                                "description": "Point type example"
+                            },
+                            {
+                                "groups": [{"id": 1, "content": "Group 1", "subgroupStack": {"A": True, "B": True}}, {"id": 2, "content": "Group 2" }],
+                                "items": [
+                                    {"content": "Subgroup 2 Background", "start": day_offset(0), "end": day_offset(4), "type": "background", "group": 1, "subgroup": "A", "subgroupOrder": 0},
+                                    {"content": "Subgroup 2 Item", "start": day_offset(5), "end": day_offset(7), "group": 1, "subgroup": "A", "subgroupOrder": 0},
+                                    {"content": "Subgroup 1 Background", "start": day_offset(0), "end": day_offset(4), "type": "background", "group": 1, "subgroup": "B", "subgroupOrder": 1},
+                                    {"content": "Subgroup 1 Item", "start": day_offset(8), "end": day_offset(10), "group": 1, "subgroup": "B", "subgroupOrder": 1},
+                                    {"content": "Full group background", "start": day_offset(5), "end": day_offset(9), "type": "background", "group": 2},
+                                    {"content": "No subgroup item 1", "start": day_offset(10), "end": day_offset(12), "group": 2},
+                                    {"content": "No subgroup item 2", "start": day_offset(13), "end": day_offset(15), "group": 2}
+                                    
+                                ],
+                                "description": "Subgroups with backgrounds and items"
+                            },
+                            {
+                                "groups": [{"id": 1, "content": "Group 1", "subgroupStack": {"A": True, "B": True}}, {"id": 2, "content": "Group 2" }],
+                                "items": [
+                                    {"content": "Subgroup 2 background", "start": day_offset(0), "end": day_offset(4), "type": "background", "group": 1, "subgroup": "A", "subgroupOrder": 0},
+                                    {"content": "Subgroup 2 range", "start": day_offset(5), "end": day_offset(7), "group": 1, "subgroup": "A", "subgroupOrder": 0},
+                                    {"content": "Subgroup 2 item", "start": day_offset(10), "group": 1, "subgroup": "A" },
+                                    {"content": "Subgroup 1 background", "start": day_offset(0), "end": day_offset(4), "type": "background", "group": 1, "subgroup": "B", "subgroupOrder": 1},
+                                    {"content": "Subgroup 1 range", "start": day_offset(8), "end": day_offset(10), "group": 1, "subgroup": "B", "subgroupOrder": 1},
+                                    {"content": "Subgroup 1 item", "start": day_offset(14), "group": 1, "subgroup": "B" },
+                                    {"content": "No subgroup item", "start": day_offset(12), "group": 1},
+                                    {"content": "Full group background", "start": day_offset(5), "end": day_offset(9), "type": "background", "group": 2},
+                                    {"content": "No subgroup range 1", "start": day_offset(11), "end": day_offset(13), "group": 2},
+                                    {"content": "No subgroup range 2", "start": day_offset(15), "end": day_offset(17), "group": 2},
+                                    {"content": "No subgroup point", "start": day_offset(1), "group": 2, "type": "point" }
+                                    
+                                ],
+                                "description": "Combination of item and group types"
+                            }
+                        ],
+                        inputs=basic_timeline
+                    )
+                
+                # Right column: JSON staging area
+                with gr.Column():
+                    gr.Markdown("### Serialized Timeline Value")
+                    json_textbox = gr.Textbox(label="JSON", lines=4)
+                    with gr.Row():
+                        pull_button = gr.Button("Pull Timeline into JSON")
+                        push_button = gr.Button("Push JSON onto Timeline", variant="primary")
+            
+            # Event handlers
+            basic_timeline.change(fn=on_timeline_change, outputs=[change_textbox]) # Triggered when the value of the timeline changes by any means
+            basic_timeline.input(fn=on_timeline_input, outputs=[input_textbox]) # Triggered when the value of the timeline changes, caused directly by a user input on the component (dragging, adding & removing items)
+            basic_timeline.select(fn=on_timeline_select, outputs=[select_textbox]) # Triggered when the timeline is clicked
+            basic_timeline.item_select(fn=on_item_select, inputs=[basic_timeline], outputs=[item_select_textbox]) # Triggered when items are selected or unselected
+            
+            pull_button.click(fn=pull_from_timeline, inputs=[basic_timeline], outputs=[json_textbox]) # Example of using the timeline as an input
+            push_button.click(fn=push_to_timeline, inputs=[json_textbox], outputs=[basic_timeline]) # Example of using the timeline as an output
+        
+        # --- Tab 2: Timeline without date ---
+        with gr.Tab("Timeline Without Date"):
+            audio_output = gr.Audio(label="Generated Audio", type="numpy", elem_id=AUDIO_ID)
+
+            dateless_timeline = VisTimeline(
+                value={
+                    "groups": [{"id": "track-length", "content": ""}, {"id": 1, "content": ""}, {"id": 2, "content": ""}, {"id": 3, "content": ""}],
+                    "items": [
+                        {"content": "", "group": "track-length", "selectable": False, "type": "background", "start": 0, "end": 6000, "className": "color-primary-600"},
+                        {"id": 1, "content": "440.00Hz", "group": 1, "selectable": False, "start": 0, "end": 1500},
+                        {"id": 2, "content": "554.37Hz", "group": 2, "selectable": False, "start": 2000, "end": 3500},
+                        {"id": 3, "content": "659.26Hz", "group": 3, "selectable": False, "start": 4000, "end": 5500}
+                    ]},
+                options={
+                    "moment": "+00:00", # Force the timeline into a certain UTC offset timezone
+                    "showCurrentTime": False,
+                    "editable": {
+                        "add": False,
+                        "remove": False,
+                        "updateGroup": False,
+                        "updateTime": True
+                    },
+                    "itemsAlwaysDraggable": { # So dragging does not require selection first
+                        "item": True,
+                        "range": True
+                    },
+                    "showMajorLabels": False, # This hides the month & year labels
+                    "format": {
+                        "minorLabels": { # Force the minor labels into a format that does not include weekdays or months
+                            "millisecond": "mm:ss.SSS",
+                            "second": "mm:ss",
+                            "minute": "mm:ss",
+                            "hour": "HH:mm:ss"
+                        }
+                    },
+                    "start": 0,      # Timeline will start at unix epoch
+                    "end": 6000,     # Initial timeline range will end at 1 minute (unix timestamp in milliseconds)
+                    "min": 0,        # Restrict timeline navigation, timeline can not be scrolled further to the left than 0 seconds
+                    "max": 7000,     # Restrict timeline navigation, timeline can not be scrolled further to the right than 70 seconds
+                    "zoomMin": 1000, # Allow zoom in up until the entire timeline spans 1000 milliseconds
+                },
+                label="Timeline without date labels, with restrictions on navigation and zoom. You can drag and resize items without having to select them first.",
+                elem_id=TIMELINE_ID  # This will also make the timeline instance accessible in JavaScript via 'window.visTimelineInstances["your elem_id"]'
+            )
+            
+            table = gr.DataFrame(
+                headers=["Item Name", "Start Time", "Duration"],
+                label="Timeline Items",
+                interactive=False
+            )
+
+            generate_audio_button = gr.Button("Generate Audio")
+            
+            # Event handlers
+            dateless_timeline.change(fn=update_table, inputs=[dateless_timeline], outputs=[table])
+            dateless_timeline.load(fn=update_table, inputs=[dateless_timeline], outputs=[table])
+            generate_audio_button.click(fn=update_audio, inputs=[dateless_timeline], outputs=[audio_output])
+
+            generate_audio_button.click(
+                fn=update_audio, 
+                inputs=[dateless_timeline], 
+                outputs=[audio_output],
+            ).then(
+                fn=None,
+                inputs=None,
+                outputs=None,
+                js=f'() => initAudioSync("{TIMELINE_ID}", "{AUDIO_ID}", 6000)'
+            )
+        
+        # --- Tab 3: Links to documentation and examples ---
+        with gr.Tab("Documentation & More Examples"):
+            gr.Markdown("""
+                ## Vis.js Timeline Examples  
+                A collection of HTML/CSS/JavaScript snippets displaying various properties and use-cases:  
+                [https://visjs.github.io/vis-timeline/examples/timeline/](https://visjs.github.io/vis-timeline/examples/timeline/)
+                <br><br>
+                ## Vis.js Timeline Documentation  
+                The official documentation of the timeline:  
+                [https://visjs.github.io/vis-timeline/docs/timeline/](https://visjs.github.io/vis-timeline/docs/timeline/)
+                <br><br>
+                ## Vis.js DataSet Documentation  
+                The official documentation of the DataSet model:  
+                [https://visjs.github.io/vis-data/data/dataset.html](https://visjs.github.io/vis-data/data/dataset.html)
+            """)
+
+if __name__ == "__main__":
+    demo.launch(show_api=False)

src/demo/custom_time_control.js

@@ -0,0 +1,121 @@
+function manageTimeBar(elemId, time) {
+    if (!window.visTimelineInstances) {
+        console.error(`Timeline instances collection not found`);
+        return;
+    }
+
+    const timeline = window.visTimelineInstances[elemId];
+    if (!timeline) {
+        console.error(`Timeline instance ${elemId} not found`);
+        return;
+    }
+    
+    if (!window.customTimeBarIds) {
+        window.customTimeBarIds = {};
+    }
+    
+    try {
+        timeline.setCustomTime(time, elemId);
+    } catch (e) {
+        timeline.addCustomTime(time, elemId);
+    }
+}
+
+function setTimeBarDirect(elemId, time) {
+    manageTimeBar(elemId, time);
+}
+
+function setTimeBarNormalized(elemId, start, end, normalizedPos) {
+    const time = start + (end - start) * normalizedPos;
+    manageTimeBar(elemId, time);
+}
+
+class AudioTimelineSync {
+    constructor(timelineId, audioId, trackLength) {
+        this.timelineId = timelineId;
+        this.trackLength = trackLength;
+        const container = document.getElementById(audioId);
+        
+        // Find the progress element through shadow DOM
+        const waveform = container.querySelector('#waveform');
+        if (!waveform) {
+            console.error('Waveform container not found');
+            return;
+        }
+
+        // Access shadow root and find progress element
+        const shadowRoot = waveform.querySelector('div').shadowRoot;
+        this.progressElement = shadowRoot.querySelector('div[part="progress"]');
+        
+        if (!this.progressElement) {
+            console.error('Progress element not found');
+            return;
+        }
+        
+        this.setupProgressObserver();
+    }
+    
+    setupProgressObserver() {
+        // Create mutation observer to watch for style changes to a specific progress element of the audio component
+        // The style is defined by the completion of the audio source, even when the audio is not playing but the time bar is being dragged by the cursor.
+        this.observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === 'attributes' && mutation.attributeName === 'style') {
+                    this.onProgressUpdate();
+                }
+            });
+        });
+        
+        // Observe the progress element for style changes
+        this.observer.observe(this.progressElement, {
+            attributes: true,
+            attributeFilter: ['style']
+        });
+    }
+    
+    onProgressUpdate() {
+        const style = this.progressElement.style;
+        const widthStr = style.width;
+        if (!widthStr) return;
+        
+        // Convert percentage string to number (e.g., "70.7421%" -> 0.707421)
+        const percentage = parseFloat(widthStr) / 100;
+        this.syncTimeBarToPlayback(percentage);
+    }
+    
+    syncTimeBarToPlayback(normalizedPosition) {
+        const timeline = window.visTimelineInstances[this.timelineId];
+        if (timeline) {
+            setTimeBarNormalized(this.timelineId, 0, this.trackLength, normalizedPosition);
+        }
+    }
+
+    cleanup() {
+        // Disconnect observer
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = null;
+        }
+    }
+}
+
+function initAudioSync(timelineId, audioId, trackLength) {
+    try {
+        // Initialize syncs container if it doesn't exist
+        if (!window.audioTimelineSyncs) {
+            window.audioTimelineSyncs = {};
+        }
+
+        // Cleanup existing sync if any
+        if (window.audioTimelineSyncs[timelineId]) {
+            window.audioTimelineSyncs[timelineId].cleanup();
+        }
+        
+        // Create new sync instance
+        window.audioTimelineSyncs[timelineId] = new AudioTimelineSync(timelineId, audioId, trackLength);
+    } catch (error) {
+        console.error('Error initializing audio sync:', error);
+    }
+
+    return null;
+}

src/demo/requirements.txt

@@ -0,0 +1 @@
+gradio_vistimeline

src/frontend/Example.svelte

@@ -0,0 +1,110 @@
+<script lang="ts">
+    interface TimelineExample {
+        groups: Array<{id: number, content: string}>;
+        items: Array<{
+            id: number | string,
+            content: string,
+            group?: number,
+            start: string,
+            end?: string
+        }>;
+        description?: string;
+    }
+
+    export let value: TimelineExample;
+    export let type: "gallery" | "table";
+    export let selected = false;
+
+    export let options: Record<string, any> | undefined = undefined;
+    export let preserve_old_content_on_value_change: boolean | undefined = undefined;
+    export let label: string | undefined = undefined;
+    export let interactive: boolean | undefined = undefined;
+    export let visible: boolean | undefined = undefined;
+    export let elem_id: string | undefined = undefined;
+    export let elem_classes: string[] | undefined = undefined;
+    export let key: string | undefined = undefined;
+    export let samples_dir: string | undefined = undefined;
+    export let index: number | undefined = undefined;
+    export let root: any = undefined;
+
+    function formatSummary(example: TimelineExample): string {
+        const itemCount = example.items.length;
+        const groupCount = example.groups.length;
+        const dateRange = getDateRange(example.items);
+        
+        const summary = example.description
+            ? example.description
+            : `${itemCount} item${itemCount !== 1 ? 's' : ''} in ${groupCount} group${groupCount !== 1 ? 's' : ''}`;
+            
+        return `${summary}\n${dateRange}`;
+    }
+
+    function getDateRange(items: TimelineExample['items']): string {
+        if (items.length === 0) return '';
+        
+        const dates = items.flatMap(item => [new Date(item.start), item.end ? new Date(item.end) : null])
+            .filter((date): date is Date => date !== null);
+            
+        const minDate = new Date(Math.min(...dates.map(d => d.getTime())));
+        const maxDate = new Date(Math.max(...dates.map(d => d.getTime())));
+        
+        if (minDate.getTime() === maxDate.getTime()) {
+            return formatDate(minDate, true);
+        }
+        
+        return `${formatDate(minDate)} - ${formatDate(maxDate)}`;
+    }
+
+    function formatDate(date: Date, fullFormat: boolean = false): string {
+        if (fullFormat) {
+            return date.toLocaleDateString('en-US', { 
+                month: 'long', 
+                day: 'numeric',
+                year: 'numeric'
+            });
+        }
+        return date.toLocaleDateString('en-US', { 
+            month: 'short', 
+            day: 'numeric',
+            year: 'numeric'
+        });
+    }
+</script>
+
+<div
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+	class="example-container"
+>
+	<div class="example-content">
+		{formatSummary(value)}
+	</div>
+</div>
+
+<style>
+    .example-container {
+        border: var(--button-border-width) solid var(--button-secondary-border-color) !important;
+        background: var(--button-secondary-background-fill) !important;
+		color: var(--button-secondary-text-color) !important;
+        border-radius: var(--button-large-radius) !important;
+        transition: all 0.2s ease;
+        cursor: pointer;
+        overflow: hidden;
+    }
+    .example-content {
+        padding: var(--spacing-md);
+        font-size: var(--text-sm);
+        white-space: pre-line;
+        line-height: 1.4;
+    }
+    .selected {
+        border: var(--button-border-width) solid var(--button-secondary-border-color-hover) !important;
+        background: var(--button-secondary-background-fill-hover) !important;
+		color: var(--button-secondary-text-color-hover) !important;
+        border-radius: var(--button-large-radius) !important;
+    }
+    .gallery {
+        min-width: 100px;
+    }
+</style>

src/frontend/Index.svelte

@@ -0,0 +1,440 @@
+<script lang="ts">
+	import { DataSet, Timeline, moment } from 'vis-timeline/standalone';
+	import 'vis-timeline/styles/vis-timeline-graph2d.css';
+
+	import type { Gradio } from "@gradio/utils";
+	import { Block } from "@gradio/atoms";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+
+	import { onMount } from 'svelte';
+
+	export let gradio: Gradio<{
+		load: any,
+		change: any,
+		input: any,
+		item_select: any,		
+		select: any
+	}>;
+
+	export let value = { groups: [], items: [] };
+	export let options: Record<string, any> = {};
+	export let preserve_old_content_on_value_change:  boolean = false;
+
+	export let label: string | null = null;
+	export let interactive: true;
+	export let visible: boolean = true;
+	export let elem_id: string = "";
+	export let elem_classes: string[] = [];
+	export let loading_status: LoadingStatus | undefined = undefined;
+
+	let container: HTMLDivElement;
+	let timeline: Timeline;
+	let groupsDataSet = new DataSet();
+	let itemsDataSet = new DataSet();
+	let inputLock = false;
+	let timelineHasGroups = false;
+	let isMounted = false;
+
+	function updateBackendState() {
+		const currentGroups = groupsDataSet ? groupsDataSet.get() : null;
+		const currentItems = itemsDataSet ? itemsDataSet.get() : null;
+		value = { groups: currentGroups, items: currentItems };
+	}
+
+	function updateFrontEndState() {
+		inputLock = true;
+
+		try {
+			let selection: [] | null = null;
+
+			if (!preserve_old_content_on_value_change && timeline) {
+				selection = timeline.getSelection();
+			}
+
+			const newValueHasGroups = value.groups.length > 0;
+			
+			if (newValueHasGroups != timelineHasGroups && isMounted)	{
+				instantiateTimeline(newValueHasGroups);
+			}
+
+			tryUpdateDataSet(value.groups, groupsDataSet);
+			tryUpdateDataSet(value.items, itemsDataSet);
+
+			if (selection && selection.length > 0) {
+            	timeline.setSelection(selection);
+        	}
+		} catch (error) {
+			console.error("Error updating frontend state:", error);
+		} finally {
+			inputLock = false;
+		}
+	}
+
+	function tryUpdateDataSet(newData, dataSet) {
+		try {
+			if (newData) {
+				if (preserve_old_content_on_value_change) {
+					removeOldDataFromDataSet(newData, dataSet);
+					dataSet.update(newData);
+				} else {
+					dataSet.clear();
+					dataSet.add(newData);
+				}
+			} else {
+				dataSet.clear();
+			}
+		} catch (error) {
+			console.error("Error updating timeline content datasets:", error);
+		}
+	}
+
+	function removeOldDataFromDataSet(newData, dataSet) {
+		if (newData) {
+			const newIds = newData.map(item => item.id);
+			const currentItems = dataSet.get();
+			const itemIdsToRemove = currentItems.filter(item => !newIds.includes(item.id)).map(item => item.id);
+
+			if (itemIdsToRemove && itemIdsToRemove.length > 0) {
+            	dataSet.remove(itemIdsToRemove);
+        	}
+		}
+	}
+
+	function instantiateTimeline(hasGroups) {
+		declareGlobalWindow();
+		parseOptions();
+
+		if (timeline) {
+			removeTimelineFromGlobalWindow();
+			timeline.destroy();
+		}
+
+		timelineHasGroups = hasGroups;
+
+		if (hasGroups) {
+			timeline = new Timeline(container, itemsDataSet, groupsDataSet, options);
+		} else {
+			timeline = new Timeline(container, itemsDataSet, options);
+		}
+
+		addTimelineToGlobalWindow();
+		listenToTimelineEvents();
+	}
+
+	function declareGlobalWindow() {
+		if (!window.visTimelineInstances) {
+			window.visTimelineInstances = {};
+		}
+	}
+
+	function removeTimelineFromGlobalWindow() {
+		if (elem_id && window.visTimelineInstances[elem_id]) {
+			delete window.visTimelineInstances[elem_id];
+		}
+	}
+
+	function addTimelineToGlobalWindow() {
+		if (elem_id) {
+			window.visTimelineInstances[elem_id] = timeline;
+		}
+	}
+
+	function parseOptions() {
+		if (options && typeof options.moment === 'string' && options.moment.trim() !== '') {
+			const offsetString = options.moment.trim();
+			options.moment = function (date) {
+				return moment(date).utcOffset(offsetString);
+			};
+    	}
+	}
+
+	function listenToTimelineEvents() {
+		timeline.on("click", (properties) => {
+			gradio.dispatch("select");
+		});
+
+		timeline.on("select", (properties) => {
+			if (!inputLock) {
+				gradio.dispatch("item_select", properties.items);
+			}
+		});
+	}
+
+	function listenToUserInput(dataSet) {
+		["update", "add", "remove"].forEach((eventType) => {
+			dataSet.on(eventType, (name, payload) => {
+				if (!inputLock) {
+					gradio.dispatch("input", eventType);
+					updateBackendState();
+				}
+			});
+		});
+	}
+
+	function addResizeObserver() {
+		const observer = new ResizeObserver((entries) => {
+			for (const entry of entries) {
+				const { width, height } = entry.contentRect;
+				
+				if (width > 0 && height > 0 && timeline) {
+					timeline.redraw();
+				}
+			}
+		});
+
+		observer.observe(container);
+	}
+
+	function onValueChange() {
+		gradio.dispatch("change");
+	}
+
+	onMount(() => {
+		instantiateTimeline(groupsDataSet.get().length > 0);
+
+		if (!interactive) {
+			timeline.setOptions({ editable: false });
+		}
+		
+		isMounted = true;
+
+		updateFrontEndState();
+		onValueChange();
+
+		listenToUserInput(itemsDataSet);
+		listenToUserInput(groupsDataSet);
+		addResizeObserver();
+
+		gradio.dispatch("load");
+	});
+
+	$: if (value) {
+		updateFrontEndState();
+		onValueChange();
+	}
+</script>
+
+<div class:hidden={!visible}>
+	<Block {elem_id} {elem_classes} allow_overflow={false} padding={true}>
+		{#if loading_status}
+			<StatusTracker
+				autoscroll={gradio.autoscroll}
+				i18n={gradio.i18n}
+				{...loading_status}
+			/>
+		{/if}
+		{#if label}<label for="{elem_id}" class="gr-vistimeline-label">{label}</label>{/if}
+		<div class="gr-vistimeline" bind:this={container}></div>
+	</Block>
+</div>
+
+<style>
+	.hidden {
+		display: none !important;
+	}
+	.gr-vistimeline-label {
+		display: inline-block;
+		position: relative;
+		z-index: var(--layer-4);
+		border: solid var(--block-title-border-width) var(--block-title-border-color);
+		border-radius: var(--block-title-radius);
+		background: var(--block-title-background-fill);
+		padding: var(--block-title-padding);
+		color: var(--block-title-text-color);
+		font-weight: var(--block-title-text-weight);
+		font-size: var(--block-title-text-size);
+		line-height: var(--line-sm);
+		margin-bottom: var(--spacing-lg);
+	}
+	.gr-vistimeline :global(.vis-timeline) {
+		border-radius: var(--block-radius) !important;
+		border-color: var(--block-border-color) !important;
+	}
+	.gr-vistimeline :global(.vis-item) {
+		border-radius: var(--block-radius) !important;
+		border-color: var(--neutral-400) !important;
+		background: var(--button-secondary-background-fill) !important;
+		color: var(--body-text-color) !important;
+		font-family: var(--font) !important;
+	}
+	.gr-vistimeline :global(.vis-item.vis-selected) {
+		border-color: var(--primary-500) !important;
+		background: var(--primary-400) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.vis-item.vis-line) {
+		width: 0px !important;
+		border-radius: 0px !important;
+		border-top-width: 0px !important;
+		border-right-width: 0px !important;
+		border-bottom-width: 0px !important;
+		border-left-width: 1px !important;
+	}
+	.gr-vistimeline :global(.vis-delete), .gr-vistimeline :global(.vis-delete-rtl) {
+		background-color: transparent !important;
+	}
+	.gr-vistimeline :global(.vis-delete::after), .gr-vistimeline :global(.vis-delete-rtl::after) {
+		color: var(--button-cancel-background-fill) !important;
+	}
+	.gr-vistimeline :global(.vis-time-axis .vis-text) {
+		color: var(--block-title-text-color) !important;
+		font-size: var(--text-md) !important;
+		padding-left: var(--spacing-sm) !important;
+	}
+	.gr-vistimeline :global(.vis-time-axis .vis-grid.vis-minor), .gr-vistimeline :global(.vis-time-axis .vis-grid.vis-major) {
+		border-color: var(--block-border-color) !important;
+	}
+	.gr-vistimeline :global(.vis-panel), .gr-vistimeline :global(.vis-group), .gr-vistimeline :global(.vis-labelset .vis-label) {
+		border-color: var(--block-border-color) !important;
+	}
+	.gr-vistimeline :global(.vis-labelset .vis-label) {
+		color: var(--block-title-text-color) !important;
+	}
+	.gr-vistimeline :global(.vis-panel) {
+		border-bottom-width: 2px !important;
+	}	
+	.gr-vistimeline :global(.vis-panel.vis-center), .gr-vistimeline :global(.vis-panel.vis-bottom) {
+		border-left-width: 2px !important;
+	}
+	.gr-vistimeline :global(.vis-current-time) {
+		background-color: var(--primary-500) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.vis-custom-time) {
+		background-color: var(--primary-600) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-50) {
+		background-color: var(--primary-50) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-100) {
+		background-color: var(--primary-100) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-200) {
+		background-color: var(--primary-200) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-300) {
+		background-color: var(--primary-300) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-400) {
+		background-color: var(--primary-400) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-500) {
+		background-color: var(--primary-500) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-600) {
+		background-color: var(--primary-600) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-700) {
+		background-color: var(--primary-700) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-800) {
+		background-color: var(--primary-800) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-900) {
+		background-color: var(--primary-900) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-primary-950) {
+		background-color: var(--primary-950) !important;
+		color: var(--button-primary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-50) {
+		background-color: var(--secondary-50) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-100) {
+		background-color: var(--secondary-100) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-200) {
+		background-color: var(--secondary-200) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-300) {
+		background-color: var(--secondary-300) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-400) {
+		background-color: var(--secondary-400) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-500) {
+		background-color: var(--secondary-500) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-600) {
+		background-color: var(--secondary-600) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-700) {
+		background-color: var(--secondary-700) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-800) {
+		background-color: var(--secondary-800) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-900) {
+		background-color: var(--secondary-900) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-secondary-950) {
+		background-color: var(--secondary-950) !important;
+		color: var(--button-secondary-text-color) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-50) {
+		background-color: var(--neutral-50) !important;
+		color: var(--neutral-950) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-100) {
+		background-color: var(--neutral-100) !important;
+		color: var(--neutral-950) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-200) {
+		background-color: var(--neutral-200) !important;
+		color: var(--neutral-950) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-300) {
+		background-color: var(--neutral-300) !important;
+		color: var(--neutral-950) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-400) {
+		background-color: var(--neutral-400) !important;
+		color: var(--neutral-950) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-500) {
+		background-color: var(--neutral-500) !important;
+		color: var(--neutral-50) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-600) {
+		background-color: var(--neutral-600) !important;
+		color: var(--neutral-50) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-700) {
+		background-color: var(--neutral-700) !important;
+		color: var(--neutral-50) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-800) {
+		background-color: var(--neutral-800) !important;
+		color: var(--neutral-50) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-900) {
+		background-color: var(--neutral-900) !important;
+		color: var(--neutral-50) !important;
+	}
+	.gr-vistimeline :global(.color-neutral-950) {
+		background-color: var(--neutral-950) !important;
+		color: var(--neutral-50) !important;
+	}
+</style>

src/frontend/gradio.config.js

@@ -0,0 +1,9 @@
+export default {
+  plugins: [],
+  svelte: {
+    preprocess: [],
+  },
+  build: {
+    target: "modules",
+  },
+};

src/frontend/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "gradio_vistimeline",
+  "version": "0.3.8",
+  "description": "Gradio UI packages",
+  "type": "module",
+  "author": "",
+  "license": "ISC",
+  "private": false,
+  "main_changeset": true,
+  "exports": {
+    ".": {
+      "gradio": "./Index.svelte",
+      "svelte": "./dist/Index.svelte",
+      "types": "./dist/Index.svelte.d.ts"
+    },
+    "./example": {
+      "gradio": "./Example.svelte",
+      "svelte": "./dist/Example.svelte",
+      "types": "./dist/Example.svelte.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@gradio/atoms": "0.11.2",
+    "@gradio/icons": "0.8.1",
+    "@gradio/statustracker": "0.9.6",
+    "@gradio/utils": "0.9.0",
+    "vis-timeline": "^7.7.3"
+  },
+  "devDependencies": {
+    "@gradio/preview": "0.13.0"
+  },
+  "peerDependencies": {
+    "svelte": "^4.2.19"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gradio-app/gradio.git",
+    "directory": "js/simpletextbox"
+  }
+}

src/frontend/tsconfig.json

@@ -0,0 +1,9 @@
+{
+    "compilerOptions": {
+      "verbatimModuleSyntax": true,
+      "strict": true,
+      "moduleResolution": "bundler",
+      "isolatedModules": true
+    }
+  }
+  

src/package.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "@gradio/atoms": "^0.11.2",
+    "@gradio/statustracker": "^0.9.6"
+  }
+}

src/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = [
+  "hatchling",
+  "hatch-requirements-txt",
+  "hatch-fancy-pypi-readme>=22.5.0",
+]
+build-backend = "hatchling.build"
+
+[project]
+name = "gradio_vistimeline"
+version = "1.0.1"
+description = "Gradio implementation for the vis.js Timeline visualization library"
+readme = "README.md"
+license = "apache-2.0"
+requires-python = ">=3.10"
+authors = [{ name = "Yelorix", email = "[email protected]" }]
+keywords = ["gradio-custom-component", "timeline", "vis timeline", "vis-timeline", "vis.js"]
+
+dependencies = ["gradio>=4.0,<6.0"]
+classifiers = [
+  'Development Status :: 3 - Alpha',
+  'Operating System :: OS Independent',
+  'Programming Language :: Python :: 3',
+  'Programming Language :: Python :: 3 :: Only',
+  'Programming Language :: Python :: 3.8',
+  'Programming Language :: Python :: 3.9',
+  'Programming Language :: Python :: 3.10',
+  'Programming Language :: Python :: 3.11',
+  'Topic :: Scientific/Engineering',
+  'Topic :: Scientific/Engineering :: Artificial Intelligence',
+  'Topic :: Scientific/Engineering :: Visualization',
+]
+
+[project.urls]
+repository = "https://github.com/Yelorix/gradio-vis-timeline"
+space = "https://huggingface.co/spaces/Yelorix/gradio_vistimeline"
+
+[project.optional-dependencies]
+dev = ["build", "twine"]
+
+[tool.hatch.build]
+artifacts = ["/backend/gradio_vistimeline/templates", "*.pyi", "/\\backend\\gradio_vistimeline\\templates"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["/backend/gradio_vistimeline"]

src/venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

src/venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/LICENSE.rst

@@ -0,0 +1,28 @@
+Copyright 2010 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

src/venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: MarkupSafe
+Version: 2.1.5
+Summary: Safely add untrusted strings to HTML/XML markup.
+Home-page: https://palletsprojects.com/p/markupsafe/
+Maintainer: Pallets
+Maintainer-email: [email protected]
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://markupsafe.palletsprojects.com/
+Project-URL: Changes, https://markupsafe.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/markupsafe/
+Project-URL: Issue Tracker, https://github.com/pallets/markupsafe/issues/
+Project-URL: Chat, https://discord.gg/pallets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+
+MarkupSafe
+==========
+
+MarkupSafe implements a text object that escapes characters so it is
+safe to use in HTML and XML. Characters that have special meanings are
+replaced so that they display as the actual characters. This mitigates
+injection attacks, meaning untrusted user input can safely be displayed
+on a page.
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    pip install -U MarkupSafe
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+Examples
+--------
+
+.. code-block:: pycon
+
+    >>> from markupsafe import Markup, escape
+
+    >>> # escape replaces special characters and wraps in Markup
+    >>> escape("<script>alert(document.cookie);</script>")
+    Markup('&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
+
+    >>> # wrap in Markup to mark text "safe" and prevent escaping
+    >>> Markup("<strong>Hello</strong>")
+    Markup('<strong>hello</strong>')
+
+    >>> escape(Markup("<strong>Hello</strong>"))
+    Markup('<strong>hello</strong>')
+
+    >>> # Markup is a str subclass
+    >>> # methods and operators escape their arguments
+    >>> template = Markup("Hello <em>{name}</em>")
+    >>> template.format(name='"World"')
+    Markup('Hello <em>&#34;World&#34;</em>')
+
+
+Donate
+------
+
+The Pallets organization develops and supports MarkupSafe and other
+popular packages. In order to grow the community of contributors and
+users, and allow the maintainers to devote more time to the projects,
+`please donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+-   Documentation: https://markupsafe.palletsprojects.com/
+-   Changes: https://markupsafe.palletsprojects.com/changes/
+-   PyPI Releases: https://pypi.org/project/MarkupSafe/
+-   Source Code: https://github.com/pallets/markupsafe/
+-   Issue Tracker: https://github.com/pallets/markupsafe/issues/
+-   Chat: https://discord.gg/pallets

src/venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+MarkupSafe-2.1.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+MarkupSafe-2.1.5.dist-info/LICENSE.rst,sha256=RjHsDbX9kKVH4zaBcmTGeYIUM4FG-KyUtKV_lu6MnsQ,1503
+MarkupSafe-2.1.5.dist-info/METADATA,sha256=icNlaniV7YIQZ1BScCVqNaRtm7MAgfw8d3OBmoSVyAY,3096
+MarkupSafe-2.1.5.dist-info/RECORD,,
+MarkupSafe-2.1.5.dist-info/WHEEL,sha256=j9Aissza3750LQHFAQyYerNjmkEON1-8w_RaZNFtKSs,102
+MarkupSafe-2.1.5.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11
+markupsafe/__init__.py,sha256=m1ysNeqf55zbEoJtaovca40ivrkEFolPlw5bGoC5Gi4,11290
+markupsafe/__pycache__/__init__.cpython-312.pyc,,
+markupsafe/__pycache__/_native.cpython-312.pyc,,
+markupsafe/_native.py,sha256=_Q7UsXCOvgdonCgqG3l5asANI6eo50EKnDM-mlwEC5M,1776
+markupsafe/_speedups.c,sha256=n3jzzaJwXcoN8nTFyA53f3vSqsWK2vujI-v6QYifjhQ,7403
+markupsafe/_speedups.cp312-win_amd64.pyd,sha256=CLz8k0mpvM-dgLP0eSHpGYHm8shlGxXoCinA12zgHsY,15872
+markupsafe/_speedups.pyi,sha256=f5QtwIOP0eLrxh2v5p6SmaYmlcHIGIfmz0DovaqL0OU,238
+markupsafe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

src/venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_amd64
+

src/venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+markupsafe

src/venv/Lib/site-packages/PIL/BdfFontFile.py

@@ -0,0 +1,133 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# bitmap distribution font (bdf) file parser
+#
+# history:
+# 1996-05-16 fl   created (as bdf2pil)
+# 1997-08-25 fl   converted to FontFile driver
+# 2001-05-25 fl   removed bogus __init__ call
+# 2002-11-20 fl   robustification (from Kevin Cazabon, Dmitry Vasiliev)
+# 2003-04-22 fl   more robustification (from Graham Dumpleton)
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1997-2003 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+
+"""
+Parse X Bitmap Distribution Format (BDF)
+"""
+from __future__ import annotations
+
+from typing import BinaryIO
+
+from . import FontFile, Image
+
+bdf_slant = {
+    "R": "Roman",
+    "I": "Italic",
+    "O": "Oblique",
+    "RI": "Reverse Italic",
+    "RO": "Reverse Oblique",
+    "OT": "Other",
+}
+
+bdf_spacing = {"P": "Proportional", "M": "Monospaced", "C": "Cell"}
+
+
+def bdf_char(
+    f: BinaryIO,
+) -> (
+    tuple[
+        str,
+        int,
+        tuple[tuple[int, int], tuple[int, int, int, int], tuple[int, int, int, int]],
+        Image.Image,
+    ]
+    | None
+):
+    # skip to STARTCHAR
+    while True:
+        s = f.readline()
+        if not s:
+            return None
+        if s[:9] == b"STARTCHAR":
+            break
+    id = s[9:].strip().decode("ascii")
+
+    # load symbol properties
+    props = {}
+    while True:
+        s = f.readline()
+        if not s or s[:6] == b"BITMAP":
+            break
+        i = s.find(b" ")
+        props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
+
+    # load bitmap
+    bitmap = bytearray()
+    while True:
+        s = f.readline()
+        if not s or s[:7] == b"ENDCHAR":
+            break
+        bitmap += s[:-1]
+
+    # The word BBX
+    # followed by the width in x (BBw), height in y (BBh),
+    # and x and y displacement (BBxoff0, BByoff0)
+    # of the lower left corner from the origin of the character.
+    width, height, x_disp, y_disp = (int(p) for p in props["BBX"].split())
+
+    # The word DWIDTH
+    # followed by the width in x and y of the character in device pixels.
+    dwx, dwy = (int(p) for p in props["DWIDTH"].split())
+
+    bbox = (
+        (dwx, dwy),
+        (x_disp, -y_disp - height, width + x_disp, -y_disp),
+        (0, 0, width, height),
+    )
+
+    try:
+        im = Image.frombytes("1", (width, height), bitmap, "hex", "1")
+    except ValueError:
+        # deal with zero-width characters
+        im = Image.new("1", (width, height))
+
+    return id, int(props["ENCODING"]), bbox, im
+
+
+class BdfFontFile(FontFile.FontFile):
+    """Font file plugin for the X11 BDF format."""
+
+    def __init__(self, fp: BinaryIO) -> None:
+        super().__init__()
+
+        s = fp.readline()
+        if s[:13] != b"STARTFONT 2.1":
+            msg = "not a valid BDF file"
+            raise SyntaxError(msg)
+
+        props = {}
+        comments = []
+
+        while True:
+            s = fp.readline()
+            if not s or s[:13] == b"ENDPROPERTIES":
+                break
+            i = s.find(b" ")
+            props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
+            if s[:i] in [b"COMMENT", b"COPYRIGHT"]:
+                if s.find(b"LogicalFontDescription") < 0:
+                    comments.append(s[i + 1 : -1].decode("ascii"))
+
+        while True:
+            c = bdf_char(fp)
+            if not c:
+                break
+            id, ch, (xy, dst, src), im = c
+            if 0 <= ch < len(self.glyph):
+                self.glyph[ch] = xy, dst, src, im

src/venv/Lib/site-packages/PIL/BlpImagePlugin.py

@@ -0,0 +1,493 @@
+"""
+Blizzard Mipmap Format (.blp)
+Jerome Leclanche <[email protected]>
+
+The contents of this file are hereby released in the public domain (CC0)
+Full text of the CC0 license:
+  https://creativecommons.org/publicdomain/zero/1.0/
+
+BLP1 files, used mostly in Warcraft III, are not fully supported.
+All types of BLP2 files used in World of Warcraft are supported.
+
+The BLP file structure consists of a header, up to 16 mipmaps of the
+texture
+
+Texture sizes must be powers of two, though the two dimensions do
+not have to be equal; 512x256 is valid, but 512x200 is not.
+The first mipmap (mipmap #0) is the full size image; each subsequent
+mipmap halves both dimensions. The final mipmap should be 1x1.
+
+BLP files come in many different flavours:
+* JPEG-compressed (type == 0) - only supported for BLP1.
+* RAW images (type == 1, encoding == 1). Each mipmap is stored as an
+  array of 8-bit values, one per pixel, left to right, top to bottom.
+  Each value is an index to the palette.
+* DXT-compressed (type == 1, encoding == 2):
+- DXT1 compression is used if alpha_encoding == 0.
+  - An additional alpha bit is used if alpha_depth == 1.
+  - DXT3 compression is used if alpha_encoding == 1.
+  - DXT5 compression is used if alpha_encoding == 7.
+"""
+
+from __future__ import annotations
+
+import abc
+import os
+import struct
+from enum import IntEnum
+from io import BytesIO
+from typing import IO
+
+from . import Image, ImageFile
+
+
+class Format(IntEnum):
+    JPEG = 0
+
+
+class Encoding(IntEnum):
+    UNCOMPRESSED = 1
+    DXT = 2
+    UNCOMPRESSED_RAW_BGRA = 3
+
+
+class AlphaEncoding(IntEnum):
+    DXT1 = 0
+    DXT3 = 1
+    DXT5 = 7
+
+
+def unpack_565(i: int) -> tuple[int, int, int]:
+    return ((i >> 11) & 0x1F) << 3, ((i >> 5) & 0x3F) << 2, (i & 0x1F) << 3
+
+
+def decode_dxt1(
+    data: bytes, alpha: bool = False
+) -> tuple[bytearray, bytearray, bytearray, bytearray]:
+    """
+    input: one "row" of data (i.e. will produce 4*width pixels)
+    """
+
+    blocks = len(data) // 8  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block_index in range(blocks):
+        # Decode next 8-byte block.
+        idx = block_index * 8
+        color0, color1, bits = struct.unpack_from("<HHI", data, idx)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        # Decode this block into 4x4 pixels
+        # Accumulate the results onto our 4 row accumulators
+        for j in range(4):
+            for i in range(4):
+                # get next control op and generate a pixel
+
+                control = bits & 3
+                bits = bits >> 2
+
+                a = 0xFF
+                if control == 0:
+                    r, g, b = r0, g0, b0
+                elif control == 1:
+                    r, g, b = r1, g1, b1
+                elif control == 2:
+                    if color0 > color1:
+                        r = (2 * r0 + r1) // 3
+                        g = (2 * g0 + g1) // 3
+                        b = (2 * b0 + b1) // 3
+                    else:
+                        r = (r0 + r1) // 2
+                        g = (g0 + g1) // 2
+                        b = (b0 + b1) // 2
+                elif control == 3:
+                    if color0 > color1:
+                        r = (2 * r1 + r0) // 3
+                        g = (2 * g1 + g0) // 3
+                        b = (2 * b1 + b0) // 3
+                    else:
+                        r, g, b, a = 0, 0, 0, 0
+
+                if alpha:
+                    ret[j].extend([r, g, b, a])
+                else:
+                    ret[j].extend([r, g, b])
+
+    return ret
+
+
+def decode_dxt3(data: bytes) -> tuple[bytearray, bytearray, bytearray, bytearray]:
+    """
+    input: one "row" of data (i.e. will produce 4*width pixels)
+    """
+
+    blocks = len(data) // 16  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block_index in range(blocks):
+        idx = block_index * 16
+        block = data[idx : idx + 16]
+        # Decode next 16-byte block.
+        bits = struct.unpack_from("<8B", block)
+        color0, color1 = struct.unpack_from("<HH", block, 8)
+
+        (code,) = struct.unpack_from("<I", block, 12)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        for j in range(4):
+            high = False  # Do we want the higher bits?
+            for i in range(4):
+                alphacode_index = (4 * j + i) // 2
+                a = bits[alphacode_index]
+                if high:
+                    high = False
+                    a >>= 4
+                else:
+                    high = True
+                    a &= 0xF
+                a *= 17  # We get a value between 0 and 15
+
+                color_code = (code >> 2 * (4 * j + i)) & 0x03
+
+                if color_code == 0:
+                    r, g, b = r0, g0, b0
+                elif color_code == 1:
+                    r, g, b = r1, g1, b1
+                elif color_code == 2:
+                    r = (2 * r0 + r1) // 3
+                    g = (2 * g0 + g1) // 3
+                    b = (2 * b0 + b1) // 3
+                elif color_code == 3:
+                    r = (2 * r1 + r0) // 3
+                    g = (2 * g1 + g0) // 3
+                    b = (2 * b1 + b0) // 3
+
+                ret[j].extend([r, g, b, a])
+
+    return ret
+
+
+def decode_dxt5(data: bytes) -> tuple[bytearray, bytearray, bytearray, bytearray]:
+    """
+    input: one "row" of data (i.e. will produce 4 * width pixels)
+    """
+
+    blocks = len(data) // 16  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block_index in range(blocks):
+        idx = block_index * 16
+        block = data[idx : idx + 16]
+        # Decode next 16-byte block.
+        a0, a1 = struct.unpack_from("<BB", block)
+
+        bits = struct.unpack_from("<6B", block, 2)
+        alphacode1 = bits[2] | (bits[3] << 8) | (bits[4] << 16) | (bits[5] << 24)
+        alphacode2 = bits[0] | (bits[1] << 8)
+
+        color0, color1 = struct.unpack_from("<HH", block, 8)
+
+        (code,) = struct.unpack_from("<I", block, 12)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        for j in range(4):
+            for i in range(4):
+                # get next control op and generate a pixel
+                alphacode_index = 3 * (4 * j + i)
+
+                if alphacode_index <= 12:
+                    alphacode = (alphacode2 >> alphacode_index) & 0x07
+                elif alphacode_index == 15:
+                    alphacode = (alphacode2 >> 15) | ((alphacode1 << 1) & 0x06)
+                else:  # alphacode_index >= 18 and alphacode_index <= 45
+                    alphacode = (alphacode1 >> (alphacode_index - 16)) & 0x07
+
+                if alphacode == 0:
+                    a = a0
+                elif alphacode == 1:
+                    a = a1
+                elif a0 > a1:
+                    a = ((8 - alphacode) * a0 + (alphacode - 1) * a1) // 7
+                elif alphacode == 6:
+                    a = 0
+                elif alphacode == 7:
+                    a = 255
+                else:
+                    a = ((6 - alphacode) * a0 + (alphacode - 1) * a1) // 5
+
+                color_code = (code >> 2 * (4 * j + i)) & 0x03
+
+                if color_code == 0:
+                    r, g, b = r0, g0, b0
+                elif color_code == 1:
+                    r, g, b = r1, g1, b1
+                elif color_code == 2:
+                    r = (2 * r0 + r1) // 3
+                    g = (2 * g0 + g1) // 3
+                    b = (2 * b0 + b1) // 3
+                elif color_code == 3:
+                    r = (2 * r1 + r0) // 3
+                    g = (2 * g1 + g0) // 3
+                    b = (2 * b1 + b0) // 3
+
+                ret[j].extend([r, g, b, a])
+
+    return ret
+
+
+class BLPFormatError(NotImplementedError):
+    pass
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix[:4] in (b"BLP1", b"BLP2")
+
+
+class BlpImageFile(ImageFile.ImageFile):
+    """
+    Blizzard Mipmap Format
+    """
+
+    format = "BLP"
+    format_description = "Blizzard Mipmap Format"
+
+    def _open(self) -> None:
+        self.magic = self.fp.read(4)
+
+        self.fp.seek(5, os.SEEK_CUR)
+        (self._blp_alpha_depth,) = struct.unpack("<b", self.fp.read(1))
+
+        self.fp.seek(2, os.SEEK_CUR)
+        self._size = struct.unpack("<II", self.fp.read(8))
+
+        if self.magic in (b"BLP1", b"BLP2"):
+            decoder = self.magic.decode()
+        else:
+            msg = f"Bad BLP magic {repr(self.magic)}"
+            raise BLPFormatError(msg)
+
+        self._mode = "RGBA" if self._blp_alpha_depth else "RGB"
+        self.tile = [ImageFile._Tile(decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
+
+
+class _BLPBaseDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
+        try:
+            self._read_blp_header()
+            self._load()
+        except struct.error as e:
+            msg = "Truncated BLP file"
+            raise OSError(msg) from e
+        return -1, 0
+
+    @abc.abstractmethod
+    def _load(self) -> None:
+        pass
+
+    def _read_blp_header(self) -> None:
+        assert self.fd is not None
+        self.fd.seek(4)
+        (self._blp_compression,) = struct.unpack("<i", self._safe_read(4))
+
+        (self._blp_encoding,) = struct.unpack("<b", self._safe_read(1))
+        (self._blp_alpha_depth,) = struct.unpack("<b", self._safe_read(1))
+        (self._blp_alpha_encoding,) = struct.unpack("<b", self._safe_read(1))
+        self.fd.seek(1, os.SEEK_CUR)  # mips
+
+        self.size = struct.unpack("<II", self._safe_read(8))
+
+        if isinstance(self, BLP1Decoder):
+            # Only present for BLP1
+            (self._blp_encoding,) = struct.unpack("<i", self._safe_read(4))
+            self.fd.seek(4, os.SEEK_CUR)  # subtype
+
+        self._blp_offsets = struct.unpack("<16I", self._safe_read(16 * 4))
+        self._blp_lengths = struct.unpack("<16I", self._safe_read(16 * 4))
+
+    def _safe_read(self, length: int) -> bytes:
+        assert self.fd is not None
+        return ImageFile._safe_read(self.fd, length)
+
+    def _read_palette(self) -> list[tuple[int, int, int, int]]:
+        ret = []
+        for i in range(256):
+            try:
+                b, g, r, a = struct.unpack("<4B", self._safe_read(4))
+            except struct.error:
+                break
+            ret.append((b, g, r, a))
+        return ret
+
+    def _read_bgra(self, palette: list[tuple[int, int, int, int]]) -> bytearray:
+        data = bytearray()
+        _data = BytesIO(self._safe_read(self._blp_lengths[0]))
+        while True:
+            try:
+                (offset,) = struct.unpack("<B", _data.read(1))
+            except struct.error:
+                break
+            b, g, r, a = palette[offset]
+            d: tuple[int, ...] = (r, g, b)
+            if self._blp_alpha_depth:
+                d += (a,)
+            data.extend(d)
+        return data
+
+
+class BLP1Decoder(_BLPBaseDecoder):
+    def _load(self) -> None:
+        if self._blp_compression == Format.JPEG:
+            self._decode_jpeg_stream()
+
+        elif self._blp_compression == 1:
+            if self._blp_encoding in (4, 5):
+                palette = self._read_palette()
+                data = self._read_bgra(palette)
+                self.set_as_raw(data)
+            else:
+                msg = f"Unsupported BLP encoding {repr(self._blp_encoding)}"
+                raise BLPFormatError(msg)
+        else:
+            msg = f"Unsupported BLP compression {repr(self._blp_encoding)}"
+            raise BLPFormatError(msg)
+
+    def _decode_jpeg_stream(self) -> None:
+        from .JpegImagePlugin import JpegImageFile
+
+        (jpeg_header_size,) = struct.unpack("<I", self._safe_read(4))
+        jpeg_header = self._safe_read(jpeg_header_size)
+        assert self.fd is not None
+        self._safe_read(self._blp_offsets[0] - self.fd.tell())  # What IS this?
+        data = self._safe_read(self._blp_lengths[0])
+        data = jpeg_header + data
+        image = JpegImageFile(BytesIO(data))
+        Image._decompression_bomb_check(image.size)
+        if image.mode == "CMYK":
+            decoder_name, extents, offset, args = image.tile[0]
+            assert isinstance(args, tuple)
+            image.tile = [
+                ImageFile._Tile(decoder_name, extents, offset, (args[0], "CMYK"))
+            ]
+        r, g, b = image.convert("RGB").split()
+        reversed_image = Image.merge("RGB", (b, g, r))
+        self.set_as_raw(reversed_image.tobytes())
+
+
+class BLP2Decoder(_BLPBaseDecoder):
+    def _load(self) -> None:
+        palette = self._read_palette()
+
+        assert self.fd is not None
+        self.fd.seek(self._blp_offsets[0])
+
+        if self._blp_compression == 1:
+            # Uncompressed or DirectX compression
+
+            if self._blp_encoding == Encoding.UNCOMPRESSED:
+                data = self._read_bgra(palette)
+
+            elif self._blp_encoding == Encoding.DXT:
+                data = bytearray()
+                if self._blp_alpha_encoding == AlphaEncoding.DXT1:
+                    linesize = (self.size[0] + 3) // 4 * 8
+                    for yb in range((self.size[1] + 3) // 4):
+                        for d in decode_dxt1(
+                            self._safe_read(linesize), alpha=bool(self._blp_alpha_depth)
+                        ):
+                            data += d
+
+                elif self._blp_alpha_encoding == AlphaEncoding.DXT3:
+                    linesize = (self.size[0] + 3) // 4 * 16
+                    for yb in range((self.size[1] + 3) // 4):
+                        for d in decode_dxt3(self._safe_read(linesize)):
+                            data += d
+
+                elif self._blp_alpha_encoding == AlphaEncoding.DXT5:
+                    linesize = (self.size[0] + 3) // 4 * 16
+                    for yb in range((self.size[1] + 3) // 4):
+                        for d in decode_dxt5(self._safe_read(linesize)):
+                            data += d
+                else:
+                    msg = f"Unsupported alpha encoding {repr(self._blp_alpha_encoding)}"
+                    raise BLPFormatError(msg)
+            else:
+                msg = f"Unknown BLP encoding {repr(self._blp_encoding)}"
+                raise BLPFormatError(msg)
+
+        else:
+            msg = f"Unknown BLP compression {repr(self._blp_compression)}"
+            raise BLPFormatError(msg)
+
+        self.set_as_raw(data)
+
+
+class BLPEncoder(ImageFile.PyEncoder):
+    _pushes_fd = True
+
+    def _write_palette(self) -> bytes:
+        data = b""
+        assert self.im is not None
+        palette = self.im.getpalette("RGBA", "RGBA")
+        for i in range(len(palette) // 4):
+            r, g, b, a = palette[i * 4 : (i + 1) * 4]
+            data += struct.pack("<4B", b, g, r, a)
+        while len(data) < 256 * 4:
+            data += b"\x00" * 4
+        return data
+
+    def encode(self, bufsize: int) -> tuple[int, int, bytes]:
+        palette_data = self._write_palette()
+
+        offset = 20 + 16 * 4 * 2 + len(palette_data)
+        data = struct.pack("<16I", offset, *((0,) * 15))
+
+        assert self.im is not None
+        w, h = self.im.size
+        data += struct.pack("<16I", w * h, *((0,) * 15))
+
+        data += palette_data
+
+        for y in range(h):
+            for x in range(w):
+                data += struct.pack("<B", self.im.getpixel((x, y)))
+
+        return len(data), 0, data
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if im.mode != "P":
+        msg = "Unsupported BLP image mode"
+        raise ValueError(msg)
+
+    magic = b"BLP1" if im.encoderinfo.get("blp_version") == "BLP1" else b"BLP2"
+    fp.write(magic)
+
+    assert im.palette is not None
+    fp.write(struct.pack("<i", 1))  # Uncompressed or DirectX compression
+    fp.write(struct.pack("<b", Encoding.UNCOMPRESSED))
+    fp.write(struct.pack("<b", 1 if im.palette.mode == "RGBA" else 0))
+    fp.write(struct.pack("<b", 0))  # alpha encoding
+    fp.write(struct.pack("<b", 0))  # mips
+    fp.write(struct.pack("<II", *im.size))
+    if magic == b"BLP1":
+        fp.write(struct.pack("<i", 5))
+        fp.write(struct.pack("<i", 0))
+
+    ImageFile._save(im, fp, [ImageFile._Tile("BLP", (0, 0) + im.size, 0, im.mode)])
+
+
+Image.register_open(BlpImageFile.format, BlpImageFile, _accept)
+Image.register_extension(BlpImageFile.format, ".blp")
+Image.register_decoder("BLP1", BLP1Decoder)
+Image.register_decoder("BLP2", BLP2Decoder)
+
+Image.register_save(BlpImageFile.format, _save)
+Image.register_encoder("BLP", BLPEncoder)

src/venv/Lib/site-packages/PIL/BmpImagePlugin.py

@@ -0,0 +1,511 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# BMP file handler
+#
+# Windows (and OS/2) native bitmap storage format.
+#
+# history:
+# 1995-09-01 fl   Created
+# 1996-04-30 fl   Added save
+# 1997-08-27 fl   Fixed save of 1-bit images
+# 1998-03-06 fl   Load P images as L where possible
+# 1998-07-03 fl   Load P images as 1 where possible
+# 1998-12-29 fl   Handle small palettes
+# 2002-12-30 fl   Fixed load of 1-bit palette images
+# 2003-04-21 fl   Fixed load of 1-bit monochrome images
+# 2003-04-23 fl   Added limited support for BI_BITFIELDS compression
+#
+# Copyright (c) 1997-2003 by Secret Labs AB
+# Copyright (c) 1995-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+from typing import IO, Any
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+from ._binary import o8
+from ._binary import o16le as o16
+from ._binary import o32le as o32
+
+#
+# --------------------------------------------------------------------
+# Read BMP file
+
+BIT2MODE = {
+    # bits => mode, rawmode
+    1: ("P", "P;1"),
+    4: ("P", "P;4"),
+    8: ("P", "P"),
+    16: ("RGB", "BGR;15"),
+    24: ("RGB", "BGR"),
+    32: ("RGB", "BGRX"),
+}
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix[:2] == b"BM"
+
+
+def _dib_accept(prefix: bytes) -> bool:
+    return i32(prefix) in [12, 40, 52, 56, 64, 108, 124]
+
+
+# =============================================================================
+# Image plugin for the Windows BMP format.
+# =============================================================================
+class BmpImageFile(ImageFile.ImageFile):
+    """Image plugin for the Windows Bitmap format (BMP)"""
+
+    # ------------------------------------------------------------- Description
+    format_description = "Windows Bitmap"
+    format = "BMP"
+
+    # -------------------------------------------------- BMP Compression values
+    COMPRESSIONS = {"RAW": 0, "RLE8": 1, "RLE4": 2, "BITFIELDS": 3, "JPEG": 4, "PNG": 5}
+    for k, v in COMPRESSIONS.items():
+        vars()[k] = v
+
+    def _bitmap(self, header: int = 0, offset: int = 0) -> None:
+        """Read relevant info about the BMP"""
+        read, seek = self.fp.read, self.fp.seek
+        if header:
+            seek(header)
+        # read bmp header size @offset 14 (this is part of the header size)
+        file_info: dict[str, bool | int | tuple[int, ...]] = {
+            "header_size": i32(read(4)),
+            "direction": -1,
+        }
+
+        # -------------------- If requested, read header at a specific position
+        # read the rest of the bmp header, without its size
+        assert isinstance(file_info["header_size"], int)
+        header_data = ImageFile._safe_read(self.fp, file_info["header_size"] - 4)
+
+        # ------------------------------- Windows Bitmap v2, IBM OS/2 Bitmap v1
+        # ----- This format has different offsets because of width/height types
+        # 12: BITMAPCOREHEADER/OS21XBITMAPHEADER
+        if file_info["header_size"] == 12:
+            file_info["width"] = i16(header_data, 0)
+            file_info["height"] = i16(header_data, 2)
+            file_info["planes"] = i16(header_data, 4)
+            file_info["bits"] = i16(header_data, 6)
+            file_info["compression"] = self.COMPRESSIONS["RAW"]
+            file_info["palette_padding"] = 3
+
+        # --------------------------------------------- Windows Bitmap v3 to v5
+        #  40: BITMAPINFOHEADER
+        #  52: BITMAPV2HEADER
+        #  56: BITMAPV3HEADER
+        #  64: BITMAPCOREHEADER2/OS22XBITMAPHEADER
+        # 108: BITMAPV4HEADER
+        # 124: BITMAPV5HEADER
+        elif file_info["header_size"] in (40, 52, 56, 64, 108, 124):
+            file_info["y_flip"] = header_data[7] == 0xFF
+            file_info["direction"] = 1 if file_info["y_flip"] else -1
+            file_info["width"] = i32(header_data, 0)
+            file_info["height"] = (
+                i32(header_data, 4)
+                if not file_info["y_flip"]
+                else 2**32 - i32(header_data, 4)
+            )
+            file_info["planes"] = i16(header_data, 8)
+            file_info["bits"] = i16(header_data, 10)
+            file_info["compression"] = i32(header_data, 12)
+            # byte size of pixel data
+            file_info["data_size"] = i32(header_data, 16)
+            file_info["pixels_per_meter"] = (
+                i32(header_data, 20),
+                i32(header_data, 24),
+            )
+            file_info["colors"] = i32(header_data, 28)
+            file_info["palette_padding"] = 4
+            assert isinstance(file_info["pixels_per_meter"], tuple)
+            self.info["dpi"] = tuple(x / 39.3701 for x in file_info["pixels_per_meter"])
+            if file_info["compression"] == self.COMPRESSIONS["BITFIELDS"]:
+                masks = ["r_mask", "g_mask", "b_mask"]
+                if len(header_data) >= 48:
+                    if len(header_data) >= 52:
+                        masks.append("a_mask")
+                    else:
+                        file_info["a_mask"] = 0x0
+                    for idx, mask in enumerate(masks):
+                        file_info[mask] = i32(header_data, 36 + idx * 4)
+                else:
+                    # 40 byte headers only have the three components in the
+                    # bitfields masks, ref:
+                    # https://msdn.microsoft.com/en-us/library/windows/desktop/dd183376(v=vs.85).aspx
+                    # See also
+                    # https://github.com/python-pillow/Pillow/issues/1293
+                    # There is a 4th component in the RGBQuad, in the alpha
+                    # location, but it is listed as a reserved component,
+                    # and it is not generally an alpha channel
+                    file_info["a_mask"] = 0x0
+                    for mask in masks:
+                        file_info[mask] = i32(read(4))
+                assert isinstance(file_info["r_mask"], int)
+                assert isinstance(file_info["g_mask"], int)
+                assert isinstance(file_info["b_mask"], int)
+                assert isinstance(file_info["a_mask"], int)
+                file_info["rgb_mask"] = (
+                    file_info["r_mask"],
+                    file_info["g_mask"],
+                    file_info["b_mask"],
+                )
+                file_info["rgba_mask"] = (
+                    file_info["r_mask"],
+                    file_info["g_mask"],
+                    file_info["b_mask"],
+                    file_info["a_mask"],
+                )
+        else:
+            msg = f"Unsupported BMP header type ({file_info['header_size']})"
+            raise OSError(msg)
+
+        # ------------------ Special case : header is reported 40, which
+        # ---------------------- is shorter than real size for bpp >= 16
+        assert isinstance(file_info["width"], int)
+        assert isinstance(file_info["height"], int)
+        self._size = file_info["width"], file_info["height"]
+
+        # ------- If color count was not found in the header, compute from bits
+        assert isinstance(file_info["bits"], int)
+        file_info["colors"] = (
+            file_info["colors"]
+            if file_info.get("colors", 0)
+            else (1 << file_info["bits"])
+        )
+        assert isinstance(file_info["colors"], int)
+        if offset == 14 + file_info["header_size"] and file_info["bits"] <= 8:
+            offset += 4 * file_info["colors"]
+
+        # ---------------------- Check bit depth for unusual unsupported values
+        self._mode, raw_mode = BIT2MODE.get(file_info["bits"], ("", ""))
+        if not self.mode:
+            msg = f"Unsupported BMP pixel depth ({file_info['bits']})"
+            raise OSError(msg)
+
+        # ---------------- Process BMP with Bitfields compression (not palette)
+        decoder_name = "raw"
+        if file_info["compression"] == self.COMPRESSIONS["BITFIELDS"]:
+            SUPPORTED: dict[int, list[tuple[int, ...]]] = {
+                32: [
+                    (0xFF0000, 0xFF00, 0xFF, 0x0),
+                    (0xFF000000, 0xFF0000, 0xFF00, 0x0),
+                    (0xFF000000, 0xFF00, 0xFF, 0x0),
+                    (0xFF000000, 0xFF0000, 0xFF00, 0xFF),
+                    (0xFF, 0xFF00, 0xFF0000, 0xFF000000),
+                    (0xFF0000, 0xFF00, 0xFF, 0xFF000000),
+                    (0xFF000000, 0xFF00, 0xFF, 0xFF0000),
+                    (0x0, 0x0, 0x0, 0x0),
+                ],
+                24: [(0xFF0000, 0xFF00, 0xFF)],
+                16: [(0xF800, 0x7E0, 0x1F), (0x7C00, 0x3E0, 0x1F)],
+            }
+            MASK_MODES = {
+                (32, (0xFF0000, 0xFF00, 0xFF, 0x0)): "BGRX",
+                (32, (0xFF000000, 0xFF0000, 0xFF00, 0x0)): "XBGR",
+                (32, (0xFF000000, 0xFF00, 0xFF, 0x0)): "BGXR",
+                (32, (0xFF000000, 0xFF0000, 0xFF00, 0xFF)): "ABGR",
+                (32, (0xFF, 0xFF00, 0xFF0000, 0xFF000000)): "RGBA",
+                (32, (0xFF0000, 0xFF00, 0xFF, 0xFF000000)): "BGRA",
+                (32, (0xFF000000, 0xFF00, 0xFF, 0xFF0000)): "BGAR",
+                (32, (0x0, 0x0, 0x0, 0x0)): "BGRA",
+                (24, (0xFF0000, 0xFF00, 0xFF)): "BGR",
+                (16, (0xF800, 0x7E0, 0x1F)): "BGR;16",
+                (16, (0x7C00, 0x3E0, 0x1F)): "BGR;15",
+            }
+            if file_info["bits"] in SUPPORTED:
+                if (
+                    file_info["bits"] == 32
+                    and file_info["rgba_mask"] in SUPPORTED[file_info["bits"]]
+                ):
+                    assert isinstance(file_info["rgba_mask"], tuple)
+                    raw_mode = MASK_MODES[(file_info["bits"], file_info["rgba_mask"])]
+                    self._mode = "RGBA" if "A" in raw_mode else self.mode
+                elif (
+                    file_info["bits"] in (24, 16)
+                    and file_info["rgb_mask"] in SUPPORTED[file_info["bits"]]
+                ):
+                    assert isinstance(file_info["rgb_mask"], tuple)
+                    raw_mode = MASK_MODES[(file_info["bits"], file_info["rgb_mask"])]
+                else:
+                    msg = "Unsupported BMP bitfields layout"
+                    raise OSError(msg)
+            else:
+                msg = "Unsupported BMP bitfields layout"
+                raise OSError(msg)
+        elif file_info["compression"] == self.COMPRESSIONS["RAW"]:
+            if file_info["bits"] == 32 and header == 22:  # 32-bit .cur offset
+                raw_mode, self._mode = "BGRA", "RGBA"
+        elif file_info["compression"] in (
+            self.COMPRESSIONS["RLE8"],
+            self.COMPRESSIONS["RLE4"],
+        ):
+            decoder_name = "bmp_rle"
+        else:
+            msg = f"Unsupported BMP compression ({file_info['compression']})"
+            raise OSError(msg)
+
+        # --------------- Once the header is processed, process the palette/LUT
+        if self.mode == "P":  # Paletted for 1, 4 and 8 bit images
+            # ---------------------------------------------------- 1-bit images
+            if not (0 < file_info["colors"] <= 65536):
+                msg = f"Unsupported BMP Palette size ({file_info['colors']})"
+                raise OSError(msg)
+            else:
+                assert isinstance(file_info["palette_padding"], int)
+                padding = file_info["palette_padding"]
+                palette = read(padding * file_info["colors"])
+                grayscale = True
+                indices = (
+                    (0, 255)
+                    if file_info["colors"] == 2
+                    else list(range(file_info["colors"]))
+                )
+
+                # ----------------- Check if grayscale and ignore palette if so
+                for ind, val in enumerate(indices):
+                    rgb = palette[ind * padding : ind * padding + 3]
+                    if rgb != o8(val) * 3:
+                        grayscale = False
+
+                # ------- If all colors are gray, white or black, ditch palette
+                if grayscale:
+                    self._mode = "1" if file_info["colors"] == 2 else "L"
+                    raw_mode = self.mode
+                else:
+                    self._mode = "P"
+                    self.palette = ImagePalette.raw(
+                        "BGRX" if padding == 4 else "BGR", palette
+                    )
+
+        # ---------------------------- Finally set the tile data for the plugin
+        self.info["compression"] = file_info["compression"]
+        args: list[Any] = [raw_mode]
+        if decoder_name == "bmp_rle":
+            args.append(file_info["compression"] == self.COMPRESSIONS["RLE4"])
+        else:
+            assert isinstance(file_info["width"], int)
+            args.append(((file_info["width"] * file_info["bits"] + 31) >> 3) & (~3))
+        args.append(file_info["direction"])
+        self.tile = [
+            ImageFile._Tile(
+                decoder_name,
+                (0, 0, file_info["width"], file_info["height"]),
+                offset or self.fp.tell(),
+                tuple(args),
+            )
+        ]
+
+    def _open(self) -> None:
+        """Open file, check magic number and read header"""
+        # read 14 bytes: magic number, filesize, reserved, header final offset
+        head_data = self.fp.read(14)
+        # choke if the file does not have the required magic bytes
+        if not _accept(head_data):
+            msg = "Not a BMP file"
+            raise SyntaxError(msg)
+        # read the start position of the BMP image data (u32)
+        offset = i32(head_data, 10)
+        # load bitmap information (offset=raster info)
+        self._bitmap(offset=offset)
+
+
+class BmpRleDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
+        assert self.fd is not None
+        rle4 = self.args[1]
+        data = bytearray()
+        x = 0
+        dest_length = self.state.xsize * self.state.ysize
+        while len(data) < dest_length:
+            pixels = self.fd.read(1)
+            byte = self.fd.read(1)
+            if not pixels or not byte:
+                break
+            num_pixels = pixels[0]
+            if num_pixels:
+                # encoded mode
+                if x + num_pixels > self.state.xsize:
+                    # Too much data for row
+                    num_pixels = max(0, self.state.xsize - x)
+                if rle4:
+                    first_pixel = o8(byte[0] >> 4)
+                    second_pixel = o8(byte[0] & 0x0F)
+                    for index in range(num_pixels):
+                        if index % 2 == 0:
+                            data += first_pixel
+                        else:
+                            data += second_pixel
+                else:
+                    data += byte * num_pixels
+                x += num_pixels
+            else:
+                if byte[0] == 0:
+                    # end of line
+                    while len(data) % self.state.xsize != 0:
+                        data += b"\x00"
+                    x = 0
+                elif byte[0] == 1:
+                    # end of bitmap
+                    break
+                elif byte[0] == 2:
+                    # delta
+                    bytes_read = self.fd.read(2)
+                    if len(bytes_read) < 2:
+                        break
+                    right, up = self.fd.read(2)
+                    data += b"\x00" * (right + up * self.state.xsize)
+                    x = len(data) % self.state.xsize
+                else:
+                    # absolute mode
+                    if rle4:
+                        # 2 pixels per byte
+                        byte_count = byte[0] // 2
+                        bytes_read = self.fd.read(byte_count)
+                        for byte_read in bytes_read:
+                            data += o8(byte_read >> 4)
+                            data += o8(byte_read & 0x0F)
+                    else:
+                        byte_count = byte[0]
+                        bytes_read = self.fd.read(byte_count)
+                        data += bytes_read
+                    if len(bytes_read) < byte_count:
+                        break
+                    x += byte[0]
+
+                    # align to 16-bit word boundary
+                    if self.fd.tell() % 2 != 0:
+                        self.fd.seek(1, os.SEEK_CUR)
+        rawmode = "L" if self.mode == "L" else "P"
+        self.set_as_raw(bytes(data), rawmode, (0, self.args[-1]))
+        return -1, 0
+
+
+# =============================================================================
+# Image plugin for the DIB format (BMP alias)
+# =============================================================================
+class DibImageFile(BmpImageFile):
+    format = "DIB"
+    format_description = "Windows Bitmap"
+
+    def _open(self) -> None:
+        self._bitmap()
+
+
+#
+# --------------------------------------------------------------------
+# Write BMP file
+
+
+SAVE = {
+    "1": ("1", 1, 2),
+    "L": ("L", 8, 256),
+    "P": ("P", 8, 256),
+    "RGB": ("BGR", 24, 0),
+    "RGBA": ("BGRA", 32, 0),
+}
+
+
+def _dib_save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    _save(im, fp, filename, False)
+
+
+def _save(
+    im: Image.Image, fp: IO[bytes], filename: str | bytes, bitmap_header: bool = True
+) -> None:
+    try:
+        rawmode, bits, colors = SAVE[im.mode]
+    except KeyError as e:
+        msg = f"cannot write mode {im.mode} as BMP"
+        raise OSError(msg) from e
+
+    info = im.encoderinfo
+
+    dpi = info.get("dpi", (96, 96))
+
+    # 1 meter == 39.3701 inches
+    ppm = tuple(int(x * 39.3701 + 0.5) for x in dpi)
+
+    stride = ((im.size[0] * bits + 7) // 8 + 3) & (~3)
+    header = 40  # or 64 for OS/2 version 2
+    image = stride * im.size[1]
+
+    if im.mode == "1":
+        palette = b"".join(o8(i) * 4 for i in (0, 255))
+    elif im.mode == "L":
+        palette = b"".join(o8(i) * 4 for i in range(256))
+    elif im.mode == "P":
+        palette = im.im.getpalette("RGB", "BGRX")
+        colors = len(palette) // 4
+    else:
+        palette = None
+
+    # bitmap header
+    if bitmap_header:
+        offset = 14 + header + colors * 4
+        file_size = offset + image
+        if file_size > 2**32 - 1:
+            msg = "File size is too large for the BMP format"
+            raise ValueError(msg)
+        fp.write(
+            b"BM"  # file type (magic)
+            + o32(file_size)  # file size
+            + o32(0)  # reserved
+            + o32(offset)  # image data offset
+        )
+
+    # bitmap info header
+    fp.write(
+        o32(header)  # info header size
+        + o32(im.size[0])  # width
+        + o32(im.size[1])  # height
+        + o16(1)  # planes
+        + o16(bits)  # depth
+        + o32(0)  # compression (0=uncompressed)
+        + o32(image)  # size of bitmap
+        + o32(ppm[0])  # resolution
+        + o32(ppm[1])  # resolution
+        + o32(colors)  # colors used
+        + o32(colors)  # colors important
+    )
+
+    fp.write(b"\0" * (header - 40))  # padding (for OS/2 format)
+
+    if palette:
+        fp.write(palette)
+
+    ImageFile._save(
+        im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))]
+    )
+
+
+#
+# --------------------------------------------------------------------
+# Registry
+
+
+Image.register_open(BmpImageFile.format, BmpImageFile, _accept)
+Image.register_save(BmpImageFile.format, _save)
+
+Image.register_extension(BmpImageFile.format, ".bmp")
+
+Image.register_mime(BmpImageFile.format, "image/bmp")
+
+Image.register_decoder("bmp_rle", BmpRleDecoder)
+
+Image.register_open(DibImageFile.format, DibImageFile, _dib_accept)
+Image.register_save(DibImageFile.format, _dib_save)
+
+Image.register_extension(DibImageFile.format, ".dib")
+
+Image.register_mime(DibImageFile.format, "image/bmp")

src/venv/Lib/site-packages/PIL/BufrStubImagePlugin.py

@@ -0,0 +1,76 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# BUFR stub adapter
+#
+# Copyright (c) 1996-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from typing import IO
+
+from . import Image, ImageFile
+
+_handler = None
+
+
+def register_handler(handler: ImageFile.StubHandler | None) -> None:
+    """
+    Install application-specific BUFR image handler.
+
+    :param handler: Handler object.
+    """
+    global _handler
+    _handler = handler
+
+
+# --------------------------------------------------------------------
+# Image adapter
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix[:4] == b"BUFR" or prefix[:4] == b"ZCZC"
+
+
+class BufrStubImageFile(ImageFile.StubImageFile):
+    format = "BUFR"
+    format_description = "BUFR"
+
+    def _open(self) -> None:
+        offset = self.fp.tell()
+
+        if not _accept(self.fp.read(4)):
+            msg = "Not a BUFR file"
+            raise SyntaxError(msg)
+
+        self.fp.seek(offset)
+
+        # make something up
+        self._mode = "F"
+        self._size = 1, 1
+
+        loader = self._load()
+        if loader:
+            loader.open(self)
+
+    def _load(self) -> ImageFile.StubHandler | None:
+        return _handler
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if _handler is None or not hasattr(_handler, "save"):
+        msg = "BUFR save handler not installed"
+        raise OSError(msg)
+    _handler.save(im, fp, filename)
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(BufrStubImageFile.format, BufrStubImageFile, _accept)
+Image.register_save(BufrStubImageFile.format, _save)
+
+Image.register_extension(BufrStubImageFile.format, ".bufr")

src/venv/Lib/site-packages/PIL/ContainerIO.py

@@ -0,0 +1,173 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# a class to read from a container file
+#
+# History:
+# 1995-06-18 fl     Created
+# 1995-09-07 fl     Added readline(), readlines()
+#
+# Copyright (c) 1997-2001 by Secret Labs AB
+# Copyright (c) 1995 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+from collections.abc import Iterable
+from typing import IO, AnyStr, NoReturn
+
+
+class ContainerIO(IO[AnyStr]):
+    """
+    A file object that provides read access to a part of an existing
+    file (for example a TAR file).
+    """
+
+    def __init__(self, file: IO[AnyStr], offset: int, length: int) -> None:
+        """
+        Create file object.
+
+        :param file: Existing file.
+        :param offset: Start of region, in bytes.
+        :param length: Size of region, in bytes.
+        """
+        self.fh: IO[AnyStr] = file
+        self.pos = 0
+        self.offset = offset
+        self.length = length
+        self.fh.seek(offset)
+
+    ##
+    # Always false.
+
+    def isatty(self) -> bool:
+        return False
+
+    def seekable(self) -> bool:
+        return True
+
+    def seek(self, offset: int, mode: int = io.SEEK_SET) -> int:
+        """
+        Move file pointer.
+
+        :param offset: Offset in bytes.
+        :param mode: Starting position. Use 0 for beginning of region, 1
+           for current offset, and 2 for end of region.  You cannot move
+           the pointer outside the defined region.
+        :returns: Offset from start of region, in bytes.
+        """
+        if mode == 1:
+            self.pos = self.pos + offset
+        elif mode == 2:
+            self.pos = self.length + offset
+        else:
+            self.pos = offset
+        # clamp
+        self.pos = max(0, min(self.pos, self.length))
+        self.fh.seek(self.offset + self.pos)
+        return self.pos
+
+    def tell(self) -> int:
+        """
+        Get current file pointer.
+
+        :returns: Offset from start of region, in bytes.
+        """
+        return self.pos
+
+    def readable(self) -> bool:
+        return True
+
+    def read(self, n: int = -1) -> AnyStr:
+        """
+        Read data.
+
+        :param n: Number of bytes to read. If omitted, zero or negative,
+            read until end of region.
+        :returns: An 8-bit string.
+        """
+        if n > 0:
+            n = min(n, self.length - self.pos)
+        else:
+            n = self.length - self.pos
+        if n <= 0:  # EOF
+            return b"" if "b" in self.fh.mode else ""  # type: ignore[return-value]
+        self.pos = self.pos + n
+        return self.fh.read(n)
+
+    def readline(self, n: int = -1) -> AnyStr:
+        """
+        Read a line of text.
+
+        :param n: Number of bytes to read. If omitted, zero or negative,
+            read until end of line.
+        :returns: An 8-bit string.
+        """
+        s: AnyStr = b"" if "b" in self.fh.mode else ""  # type: ignore[assignment]
+        newline_character = b"\n" if "b" in self.fh.mode else "\n"
+        while True:
+            c = self.read(1)
+            if not c:
+                break
+            s = s + c
+            if c == newline_character or len(s) == n:
+                break
+        return s
+
+    def readlines(self, n: int | None = -1) -> list[AnyStr]:
+        """
+        Read multiple lines of text.
+
+        :param n: Number of lines to read. If omitted, zero, negative or None,
+            read until end of region.
+        :returns: A list of 8-bit strings.
+        """
+        lines = []
+        while True:
+            s = self.readline()
+            if not s:
+                break
+            lines.append(s)
+            if len(lines) == n:
+                break
+        return lines
+
+    def writable(self) -> bool:
+        return False
+
+    def write(self, b: AnyStr) -> NoReturn:
+        raise NotImplementedError()
+
+    def writelines(self, lines: Iterable[AnyStr]) -> NoReturn:
+        raise NotImplementedError()
+
+    def truncate(self, size: int | None = None) -> int:
+        raise NotImplementedError()
+
+    def __enter__(self) -> ContainerIO[AnyStr]:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+    def __iter__(self) -> ContainerIO[AnyStr]:
+        return self
+
+    def __next__(self) -> AnyStr:
+        line = self.readline()
+        if not line:
+            msg = "end of region"
+            raise StopIteration(msg)
+        return line
+
+    def fileno(self) -> int:
+        return self.fh.fileno()
+
+    def flush(self) -> None:
+        self.fh.flush()
+
+    def close(self) -> None:
+        self.fh.close()

src/venv/Lib/site-packages/PIL/CurImagePlugin.py

@@ -0,0 +1,75 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# Windows Cursor support for PIL
+#
+# notes:
+#       uses BmpImagePlugin.py to read the bitmap data.
+#
+# history:
+#       96-05-27 fl     Created
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from . import BmpImagePlugin, Image, ImageFile
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+
+#
+# --------------------------------------------------------------------
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix[:4] == b"\0\0\2\0"
+
+
+##
+# Image plugin for Windows Cursor files.
+
+
+class CurImageFile(BmpImagePlugin.BmpImageFile):
+    format = "CUR"
+    format_description = "Windows Cursor"
+
+    def _open(self) -> None:
+        offset = self.fp.tell()
+
+        # check magic
+        s = self.fp.read(6)
+        if not _accept(s):
+            msg = "not a CUR file"
+            raise SyntaxError(msg)
+
+        # pick the largest cursor in the file
+        m = b""
+        for i in range(i16(s, 4)):
+            s = self.fp.read(16)
+            if not m:
+                m = s
+            elif s[0] > m[0] and s[1] > m[1]:
+                m = s
+        if not m:
+            msg = "No cursors were found"
+            raise TypeError(msg)
+
+        # load as bitmap
+        self._bitmap(i32(m, 12) + offset)
+
+        # patch up the bitmap height
+        self._size = self.size[0], self.size[1] // 2
+        d, e, o, a = self.tile[0]
+        self.tile[0] = ImageFile._Tile(d, (0, 0) + self.size, o, a)
+
+
+#
+# --------------------------------------------------------------------
+
+Image.register_open(CurImageFile.format, CurImageFile, _accept)
+
+Image.register_extension(CurImageFile.format, ".cur")

src/venv/Lib/site-packages/PIL/DcxImagePlugin.py

@@ -0,0 +1,80 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# DCX file handling
+#
+# DCX is a container file format defined by Intel, commonly used
+# for fax applications.  Each DCX file consists of a directory
+# (a list of file offsets) followed by a set of (usually 1-bit)
+# PCX files.
+#
+# History:
+# 1995-09-09 fl   Created
+# 1996-03-20 fl   Properly derived from PcxImageFile.
+# 1998-07-15 fl   Renamed offset attribute to avoid name clash
+# 2002-07-30 fl   Fixed file handling
+#
+# Copyright (c) 1997-98 by Secret Labs AB.
+# Copyright (c) 1995-96 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from . import Image
+from ._binary import i32le as i32
+from .PcxImagePlugin import PcxImageFile
+
+MAGIC = 0x3ADE68B1  # QUIZ: what's this value, then?
+
+
+def _accept(prefix: bytes) -> bool:
+    return len(prefix) >= 4 and i32(prefix) == MAGIC
+
+
+##
+# Image plugin for the Intel DCX format.
+
+
+class DcxImageFile(PcxImageFile):
+    format = "DCX"
+    format_description = "Intel DCX"
+    _close_exclusive_fp_after_loading = False
+
+    def _open(self) -> None:
+        # Header
+        s = self.fp.read(4)
+        if not _accept(s):
+            msg = "not a DCX file"
+            raise SyntaxError(msg)
+
+        # Component directory
+        self._offset = []
+        for i in range(1024):
+            offset = i32(self.fp.read(4))
+            if not offset:
+                break
+            self._offset.append(offset)
+
+        self._fp = self.fp
+        self.frame = -1
+        self.n_frames = len(self._offset)
+        self.is_animated = self.n_frames > 1
+        self.seek(0)
+
+    def seek(self, frame: int) -> None:
+        if not self._seek_check(frame):
+            return
+        self.frame = frame
+        self.fp = self._fp
+        self.fp.seek(self._offset[frame])
+        PcxImageFile._open(self)
+
+    def tell(self) -> int:
+        return self.frame
+
+
+Image.register_open(DcxImageFile.format, DcxImageFile, _accept)
+
+Image.register_extension(DcxImageFile.format, ".dcx")

src/venv/Lib/site-packages/PIL/DdsImagePlugin.py

@@ -0,0 +1,575 @@
+"""
+A Pillow loader for .dds files (S3TC-compressed aka DXTC)
+Jerome Leclanche <[email protected]>
+
+Documentation:
+https://web.archive.org/web/20170802060935/http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_compression_s3tc.txt
+
+The contents of this file are hereby released in the public domain (CC0)
+Full text of the CC0 license:
+https://creativecommons.org/publicdomain/zero/1.0/
+"""
+
+from __future__ import annotations
+
+import io
+import struct
+import sys
+from enum import IntEnum, IntFlag
+from typing import IO
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i32le as i32
+from ._binary import o8
+from ._binary import o32le as o32
+
+# Magic ("DDS ")
+DDS_MAGIC = 0x20534444
+
+
+# DDS flags
+class DDSD(IntFlag):
+    CAPS = 0x1
+    HEIGHT = 0x2
+    WIDTH = 0x4
+    PITCH = 0x8
+    PIXELFORMAT = 0x1000
+    MIPMAPCOUNT = 0x20000
+    LINEARSIZE = 0x80000
+    DEPTH = 0x800000
+
+
+# DDS caps
+class DDSCAPS(IntFlag):
+    COMPLEX = 0x8
+    TEXTURE = 0x1000
+    MIPMAP = 0x400000
+
+
+class DDSCAPS2(IntFlag):
+    CUBEMAP = 0x200
+    CUBEMAP_POSITIVEX = 0x400
+    CUBEMAP_NEGATIVEX = 0x800
+    CUBEMAP_POSITIVEY = 0x1000
+    CUBEMAP_NEGATIVEY = 0x2000
+    CUBEMAP_POSITIVEZ = 0x4000
+    CUBEMAP_NEGATIVEZ = 0x8000
+    VOLUME = 0x200000
+
+
+# Pixel Format
+class DDPF(IntFlag):
+    ALPHAPIXELS = 0x1
+    ALPHA = 0x2
+    FOURCC = 0x4
+    PALETTEINDEXED8 = 0x20
+    RGB = 0x40
+    LUMINANCE = 0x20000
+
+
+# dxgiformat.h
+class DXGI_FORMAT(IntEnum):
+    UNKNOWN = 0
+    R32G32B32A32_TYPELESS = 1
+    R32G32B32A32_FLOAT = 2
+    R32G32B32A32_UINT = 3
+    R32G32B32A32_SINT = 4
+    R32G32B32_TYPELESS = 5
+    R32G32B32_FLOAT = 6
+    R32G32B32_UINT = 7
+    R32G32B32_SINT = 8
+    R16G16B16A16_TYPELESS = 9
+    R16G16B16A16_FLOAT = 10
+    R16G16B16A16_UNORM = 11
+    R16G16B16A16_UINT = 12
+    R16G16B16A16_SNORM = 13
+    R16G16B16A16_SINT = 14
+    R32G32_TYPELESS = 15
+    R32G32_FLOAT = 16
+    R32G32_UINT = 17
+    R32G32_SINT = 18
+    R32G8X24_TYPELESS = 19
+    D32_FLOAT_S8X24_UINT = 20
+    R32_FLOAT_X8X24_TYPELESS = 21
+    X32_TYPELESS_G8X24_UINT = 22
+    R10G10B10A2_TYPELESS = 23
+    R10G10B10A2_UNORM = 24
+    R10G10B10A2_UINT = 25
+    R11G11B10_FLOAT = 26
+    R8G8B8A8_TYPELESS = 27
+    R8G8B8A8_UNORM = 28
+    R8G8B8A8_UNORM_SRGB = 29
+    R8G8B8A8_UINT = 30
+    R8G8B8A8_SNORM = 31
+    R8G8B8A8_SINT = 32
+    R16G16_TYPELESS = 33
+    R16G16_FLOAT = 34
+    R16G16_UNORM = 35
+    R16G16_UINT = 36
+    R16G16_SNORM = 37
+    R16G16_SINT = 38
+    R32_TYPELESS = 39
+    D32_FLOAT = 40
+    R32_FLOAT = 41
+    R32_UINT = 42
+    R32_SINT = 43
+    R24G8_TYPELESS = 44
+    D24_UNORM_S8_UINT = 45
+    R24_UNORM_X8_TYPELESS = 46
+    X24_TYPELESS_G8_UINT = 47
+    R8G8_TYPELESS = 48
+    R8G8_UNORM = 49
+    R8G8_UINT = 50
+    R8G8_SNORM = 51
+    R8G8_SINT = 52
+    R16_TYPELESS = 53
+    R16_FLOAT = 54
+    D16_UNORM = 55
+    R16_UNORM = 56
+    R16_UINT = 57
+    R16_SNORM = 58
+    R16_SINT = 59
+    R8_TYPELESS = 60
+    R8_UNORM = 61
+    R8_UINT = 62
+    R8_SNORM = 63
+    R8_SINT = 64
+    A8_UNORM = 65
+    R1_UNORM = 66
+    R9G9B9E5_SHAREDEXP = 67
+    R8G8_B8G8_UNORM = 68
+    G8R8_G8B8_UNORM = 69
+    BC1_TYPELESS = 70
+    BC1_UNORM = 71
+    BC1_UNORM_SRGB = 72
+    BC2_TYPELESS = 73
+    BC2_UNORM = 74
+    BC2_UNORM_SRGB = 75
+    BC3_TYPELESS = 76
+    BC3_UNORM = 77
+    BC3_UNORM_SRGB = 78
+    BC4_TYPELESS = 79
+    BC4_UNORM = 80
+    BC4_SNORM = 81
+    BC5_TYPELESS = 82
+    BC5_UNORM = 83
+    BC5_SNORM = 84
+    B5G6R5_UNORM = 85
+    B5G5R5A1_UNORM = 86
+    B8G8R8A8_UNORM = 87
+    B8G8R8X8_UNORM = 88
+    R10G10B10_XR_BIAS_A2_UNORM = 89
+    B8G8R8A8_TYPELESS = 90
+    B8G8R8A8_UNORM_SRGB = 91
+    B8G8R8X8_TYPELESS = 92
+    B8G8R8X8_UNORM_SRGB = 93
+    BC6H_TYPELESS = 94
+    BC6H_UF16 = 95
+    BC6H_SF16 = 96
+    BC7_TYPELESS = 97
+    BC7_UNORM = 98
+    BC7_UNORM_SRGB = 99
+    AYUV = 100
+    Y410 = 101
+    Y416 = 102
+    NV12 = 103
+    P010 = 104
+    P016 = 105
+    OPAQUE_420 = 106
+    YUY2 = 107
+    Y210 = 108
+    Y216 = 109
+    NV11 = 110
+    AI44 = 111
+    IA44 = 112
+    P8 = 113
+    A8P8 = 114
+    B4G4R4A4_UNORM = 115
+    P208 = 130
+    V208 = 131
+    V408 = 132
+    SAMPLER_FEEDBACK_MIN_MIP_OPAQUE = 189
+    SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190
+
+
+class D3DFMT(IntEnum):
+    UNKNOWN = 0
+    R8G8B8 = 20
+    A8R8G8B8 = 21
+    X8R8G8B8 = 22
+    R5G6B5 = 23
+    X1R5G5B5 = 24
+    A1R5G5B5 = 25
+    A4R4G4B4 = 26
+    R3G3B2 = 27
+    A8 = 28
+    A8R3G3B2 = 29
+    X4R4G4B4 = 30
+    A2B10G10R10 = 31
+    A8B8G8R8 = 32
+    X8B8G8R8 = 33
+    G16R16 = 34
+    A2R10G10B10 = 35
+    A16B16G16R16 = 36
+    A8P8 = 40
+    P8 = 41
+    L8 = 50
+    A8L8 = 51
+    A4L4 = 52
+    V8U8 = 60
+    L6V5U5 = 61
+    X8L8V8U8 = 62
+    Q8W8V8U8 = 63
+    V16U16 = 64
+    A2W10V10U10 = 67
+    D16_LOCKABLE = 70
+    D32 = 71
+    D15S1 = 73
+    D24S8 = 75
+    D24X8 = 77
+    D24X4S4 = 79
+    D16 = 80
+    D32F_LOCKABLE = 82
+    D24FS8 = 83
+    D32_LOCKABLE = 84
+    S8_LOCKABLE = 85
+    L16 = 81
+    VERTEXDATA = 100
+    INDEX16 = 101
+    INDEX32 = 102
+    Q16W16V16U16 = 110
+    R16F = 111
+    G16R16F = 112
+    A16B16G16R16F = 113
+    R32F = 114
+    G32R32F = 115
+    A32B32G32R32F = 116
+    CxV8U8 = 117
+    A1 = 118
+    A2B10G10R10_XR_BIAS = 119
+    BINARYBUFFER = 199
+
+    UYVY = i32(b"UYVY")
+    R8G8_B8G8 = i32(b"RGBG")
+    YUY2 = i32(b"YUY2")
+    G8R8_G8B8 = i32(b"GRGB")
+    DXT1 = i32(b"DXT1")
+    DXT2 = i32(b"DXT2")
+    DXT3 = i32(b"DXT3")
+    DXT4 = i32(b"DXT4")
+    DXT5 = i32(b"DXT5")
+    DX10 = i32(b"DX10")
+    BC4S = i32(b"BC4S")
+    BC4U = i32(b"BC4U")
+    BC5S = i32(b"BC5S")
+    BC5U = i32(b"BC5U")
+    ATI1 = i32(b"ATI1")
+    ATI2 = i32(b"ATI2")
+    MULTI2_ARGB8 = i32(b"MET1")
+
+
+# Backward compatibility layer
+module = sys.modules[__name__]
+for item in DDSD:
+    assert item.name is not None
+    setattr(module, f"DDSD_{item.name}", item.value)
+for item1 in DDSCAPS:
+    assert item1.name is not None
+    setattr(module, f"DDSCAPS_{item1.name}", item1.value)
+for item2 in DDSCAPS2:
+    assert item2.name is not None
+    setattr(module, f"DDSCAPS2_{item2.name}", item2.value)
+for item3 in DDPF:
+    assert item3.name is not None
+    setattr(module, f"DDPF_{item3.name}", item3.value)
+
+DDS_FOURCC = DDPF.FOURCC
+DDS_RGB = DDPF.RGB
+DDS_RGBA = DDPF.RGB | DDPF.ALPHAPIXELS
+DDS_LUMINANCE = DDPF.LUMINANCE
+DDS_LUMINANCEA = DDPF.LUMINANCE | DDPF.ALPHAPIXELS
+DDS_ALPHA = DDPF.ALPHA
+DDS_PAL8 = DDPF.PALETTEINDEXED8
+
+DDS_HEADER_FLAGS_TEXTURE = DDSD.CAPS | DDSD.HEIGHT | DDSD.WIDTH | DDSD.PIXELFORMAT
+DDS_HEADER_FLAGS_MIPMAP = DDSD.MIPMAPCOUNT
+DDS_HEADER_FLAGS_VOLUME = DDSD.DEPTH
+DDS_HEADER_FLAGS_PITCH = DDSD.PITCH
+DDS_HEADER_FLAGS_LINEARSIZE = DDSD.LINEARSIZE
+
+DDS_HEIGHT = DDSD.HEIGHT
+DDS_WIDTH = DDSD.WIDTH
+
+DDS_SURFACE_FLAGS_TEXTURE = DDSCAPS.TEXTURE
+DDS_SURFACE_FLAGS_MIPMAP = DDSCAPS.COMPLEX | DDSCAPS.MIPMAP
+DDS_SURFACE_FLAGS_CUBEMAP = DDSCAPS.COMPLEX
+
+DDS_CUBEMAP_POSITIVEX = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_POSITIVEX
+DDS_CUBEMAP_NEGATIVEX = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_NEGATIVEX
+DDS_CUBEMAP_POSITIVEY = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_POSITIVEY
+DDS_CUBEMAP_NEGATIVEY = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_NEGATIVEY
+DDS_CUBEMAP_POSITIVEZ = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_POSITIVEZ
+DDS_CUBEMAP_NEGATIVEZ = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_NEGATIVEZ
+
+DXT1_FOURCC = D3DFMT.DXT1
+DXT3_FOURCC = D3DFMT.DXT3
+DXT5_FOURCC = D3DFMT.DXT5
+
+DXGI_FORMAT_R8G8B8A8_TYPELESS = DXGI_FORMAT.R8G8B8A8_TYPELESS
+DXGI_FORMAT_R8G8B8A8_UNORM = DXGI_FORMAT.R8G8B8A8_UNORM
+DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = DXGI_FORMAT.R8G8B8A8_UNORM_SRGB
+DXGI_FORMAT_BC5_TYPELESS = DXGI_FORMAT.BC5_TYPELESS
+DXGI_FORMAT_BC5_UNORM = DXGI_FORMAT.BC5_UNORM
+DXGI_FORMAT_BC5_SNORM = DXGI_FORMAT.BC5_SNORM
+DXGI_FORMAT_BC6H_UF16 = DXGI_FORMAT.BC6H_UF16
+DXGI_FORMAT_BC6H_SF16 = DXGI_FORMAT.BC6H_SF16
+DXGI_FORMAT_BC7_TYPELESS = DXGI_FORMAT.BC7_TYPELESS
+DXGI_FORMAT_BC7_UNORM = DXGI_FORMAT.BC7_UNORM
+DXGI_FORMAT_BC7_UNORM_SRGB = DXGI_FORMAT.BC7_UNORM_SRGB
+
+
+class DdsImageFile(ImageFile.ImageFile):
+    format = "DDS"
+    format_description = "DirectDraw Surface"
+
+    def _open(self) -> None:
+        if not _accept(self.fp.read(4)):
+            msg = "not a DDS file"
+            raise SyntaxError(msg)
+        (header_size,) = struct.unpack("<I", self.fp.read(4))
+        if header_size != 124:
+            msg = f"Unsupported header size {repr(header_size)}"
+            raise OSError(msg)
+        header_bytes = self.fp.read(header_size - 4)
+        if len(header_bytes) != 120:
+            msg = f"Incomplete header: {len(header_bytes)} bytes"
+            raise OSError(msg)
+        header = io.BytesIO(header_bytes)
+
+        flags, height, width = struct.unpack("<3I", header.read(12))
+        self._size = (width, height)
+        extents = (0, 0) + self.size
+
+        pitch, depth, mipmaps = struct.unpack("<3I", header.read(12))
+        struct.unpack("<11I", header.read(44))  # reserved
+
+        # pixel format
+        pfsize, pfflags, fourcc, bitcount = struct.unpack("<4I", header.read(16))
+        n = 0
+        rawmode = None
+        if pfflags & DDPF.RGB:
+            # Texture contains uncompressed RGB data
+            if pfflags & DDPF.ALPHAPIXELS:
+                self._mode = "RGBA"
+                mask_count = 4
+            else:
+                self._mode = "RGB"
+                mask_count = 3
+
+            masks = struct.unpack(f"<{mask_count}I", header.read(mask_count * 4))
+            self.tile = [ImageFile._Tile("dds_rgb", extents, 0, (bitcount, masks))]
+            return
+        elif pfflags & DDPF.LUMINANCE:
+            if bitcount == 8:
+                self._mode = "L"
+            elif bitcount == 16 and pfflags & DDPF.ALPHAPIXELS:
+                self._mode = "LA"
+            else:
+                msg = f"Unsupported bitcount {bitcount} for {pfflags}"
+                raise OSError(msg)
+        elif pfflags & DDPF.PALETTEINDEXED8:
+            self._mode = "P"
+            self.palette = ImagePalette.raw("RGBA", self.fp.read(1024))
+            self.palette.mode = "RGBA"
+        elif pfflags & DDPF.FOURCC:
+            offset = header_size + 4
+            if fourcc == D3DFMT.DXT1:
+                self._mode = "RGBA"
+                self.pixel_format = "DXT1"
+                n = 1
+            elif fourcc == D3DFMT.DXT3:
+                self._mode = "RGBA"
+                self.pixel_format = "DXT3"
+                n = 2
+            elif fourcc == D3DFMT.DXT5:
+                self._mode = "RGBA"
+                self.pixel_format = "DXT5"
+                n = 3
+            elif fourcc in (D3DFMT.BC4U, D3DFMT.ATI1):
+                self._mode = "L"
+                self.pixel_format = "BC4"
+                n = 4
+            elif fourcc == D3DFMT.BC5S:
+                self._mode = "RGB"
+                self.pixel_format = "BC5S"
+                n = 5
+            elif fourcc in (D3DFMT.BC5U, D3DFMT.ATI2):
+                self._mode = "RGB"
+                self.pixel_format = "BC5"
+                n = 5
+            elif fourcc == D3DFMT.DX10:
+                offset += 20
+                # ignoring flags which pertain to volume textures and cubemaps
+                (dxgi_format,) = struct.unpack("<I", self.fp.read(4))
+                self.fp.read(16)
+                if dxgi_format in (
+                    DXGI_FORMAT.BC1_UNORM,
+                    DXGI_FORMAT.BC1_TYPELESS,
+                ):
+                    self._mode = "RGBA"
+                    self.pixel_format = "BC1"
+                    n = 1
+                elif dxgi_format in (DXGI_FORMAT.BC4_TYPELESS, DXGI_FORMAT.BC4_UNORM):
+                    self._mode = "L"
+                    self.pixel_format = "BC4"
+                    n = 4
+                elif dxgi_format in (DXGI_FORMAT.BC5_TYPELESS, DXGI_FORMAT.BC5_UNORM):
+                    self._mode = "RGB"
+                    self.pixel_format = "BC5"
+                    n = 5
+                elif dxgi_format == DXGI_FORMAT.BC5_SNORM:
+                    self._mode = "RGB"
+                    self.pixel_format = "BC5S"
+                    n = 5
+                elif dxgi_format == DXGI_FORMAT.BC6H_UF16:
+                    self._mode = "RGB"
+                    self.pixel_format = "BC6H"
+                    n = 6
+                elif dxgi_format == DXGI_FORMAT.BC6H_SF16:
+                    self._mode = "RGB"
+                    self.pixel_format = "BC6HS"
+                    n = 6
+                elif dxgi_format in (
+                    DXGI_FORMAT.BC7_TYPELESS,
+                    DXGI_FORMAT.BC7_UNORM,
+                    DXGI_FORMAT.BC7_UNORM_SRGB,
+                ):
+                    self._mode = "RGBA"
+                    self.pixel_format = "BC7"
+                    n = 7
+                    if dxgi_format == DXGI_FORMAT.BC7_UNORM_SRGB:
+                        self.info["gamma"] = 1 / 2.2
+                elif dxgi_format in (
+                    DXGI_FORMAT.R8G8B8A8_TYPELESS,
+                    DXGI_FORMAT.R8G8B8A8_UNORM,
+                    DXGI_FORMAT.R8G8B8A8_UNORM_SRGB,
+                ):
+                    self._mode = "RGBA"
+                    if dxgi_format == DXGI_FORMAT.R8G8B8A8_UNORM_SRGB:
+                        self.info["gamma"] = 1 / 2.2
+                else:
+                    msg = f"Unimplemented DXGI format {dxgi_format}"
+                    raise NotImplementedError(msg)
+            else:
+                msg = f"Unimplemented pixel format {repr(fourcc)}"
+                raise NotImplementedError(msg)
+        else:
+            msg = f"Unknown pixel format flags {pfflags}"
+            raise NotImplementedError(msg)
+
+        if n:
+            self.tile = [
+                ImageFile._Tile("bcn", extents, offset, (n, self.pixel_format))
+            ]
+        else:
+            self.tile = [ImageFile._Tile("raw", extents, 0, rawmode or self.mode)]
+
+    def load_seek(self, pos: int) -> None:
+        pass
+
+
+class DdsRgbDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
+        assert self.fd is not None
+        bitcount, masks = self.args
+
+        # Some masks will be padded with zeros, e.g. R 0b11 G 0b1100
+        # Calculate how many zeros each mask is padded with
+        mask_offsets = []
+        # And the maximum value of each channel without the padding
+        mask_totals = []
+        for mask in masks:
+            offset = 0
+            if mask != 0:
+                while mask >> (offset + 1) << (offset + 1) == mask:
+                    offset += 1
+            mask_offsets.append(offset)
+            mask_totals.append(mask >> offset)
+
+        data = bytearray()
+        bytecount = bitcount // 8
+        dest_length = self.state.xsize * self.state.ysize * len(masks)
+        while len(data) < dest_length:
+            value = int.from_bytes(self.fd.read(bytecount), "little")
+            for i, mask in enumerate(masks):
+                masked_value = value & mask
+                # Remove the zero padding, and scale it to 8 bits
+                data += o8(
+                    int(((masked_value >> mask_offsets[i]) / mask_totals[i]) * 255)
+                )
+        self.set_as_raw(data)
+        return -1, 0
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if im.mode not in ("RGB", "RGBA", "L", "LA"):
+        msg = f"cannot write mode {im.mode} as DDS"
+        raise OSError(msg)
+
+    alpha = im.mode[-1] == "A"
+    if im.mode[0] == "L":
+        pixel_flags = DDPF.LUMINANCE
+        rawmode = im.mode
+        if alpha:
+            rgba_mask = [0x000000FF, 0x000000FF, 0x000000FF]
+        else:
+            rgba_mask = [0xFF000000, 0xFF000000, 0xFF000000]
+    else:
+        pixel_flags = DDPF.RGB
+        rawmode = im.mode[::-1]
+        rgba_mask = [0x00FF0000, 0x0000FF00, 0x000000FF]
+
+        if alpha:
+            r, g, b, a = im.split()
+            im = Image.merge("RGBA", (a, r, g, b))
+    if alpha:
+        pixel_flags |= DDPF.ALPHAPIXELS
+    rgba_mask.append(0xFF000000 if alpha else 0)
+
+    flags = DDSD.CAPS | DDSD.HEIGHT | DDSD.WIDTH | DDSD.PITCH | DDSD.PIXELFORMAT
+    bitcount = len(im.getbands()) * 8
+    pitch = (im.width * bitcount + 7) // 8
+
+    fp.write(
+        o32(DDS_MAGIC)
+        + struct.pack(
+            "<7I",
+            124,  # header size
+            flags,  # flags
+            im.height,
+            im.width,
+            pitch,
+            0,  # depth
+            0,  # mipmaps
+        )
+        + struct.pack("11I", *((0,) * 11))  # reserved
+        # pfsize, pfflags, fourcc, bitcount
+        + struct.pack("<4I", 32, pixel_flags, 0, bitcount)
+        + struct.pack("<4I", *rgba_mask)  # dwRGBABitMask
+        + struct.pack("<5I", DDSCAPS.TEXTURE, 0, 0, 0, 0)
+    )
+    ImageFile._save(
+        im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))]
+    )
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix[:4] == b"DDS "
+
+
+Image.register_open(DdsImageFile.format, DdsImageFile, _accept)
+Image.register_decoder("dds_rgb", DdsRgbDecoder)
+Image.register_save(DdsImageFile.format, _save)
+Image.register_extension(DdsImageFile.format, ".dds")

src/venv/Lib/site-packages/PIL/EpsImagePlugin.py

@@ -0,0 +1,474 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# EPS file handling
+#
+# History:
+# 1995-09-01 fl   Created (0.1)
+# 1996-05-18 fl   Don't choke on "atend" fields, Ghostscript interface (0.2)
+# 1996-08-22 fl   Don't choke on floating point BoundingBox values
+# 1996-08-23 fl   Handle files from Macintosh (0.3)
+# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.4)
+# 2003-09-07 fl   Check gs.close status (from Federico Di Gregorio) (0.5)
+# 2014-05-07 e    Handling of EPS with binary preview and fixed resolution
+#                 resizing
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1995-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from typing import IO
+
+from . import Image, ImageFile
+from ._binary import i32le as i32
+
+# --------------------------------------------------------------------
+
+
+split = re.compile(r"^%%([^:]*):[ \t]*(.*)[ \t]*$")
+field = re.compile(r"^%[%!\w]([^:]*)[ \t]*$")
+
+gs_binary: str | bool | None = None
+gs_windows_binary = None
+
+
+def has_ghostscript() -> bool:
+    global gs_binary, gs_windows_binary
+    if gs_binary is None:
+        if sys.platform.startswith("win"):
+            if gs_windows_binary is None:
+                import shutil
+
+                for binary in ("gswin32c", "gswin64c", "gs"):
+                    if shutil.which(binary) is not None:
+                        gs_windows_binary = binary
+                        break
+                else:
+                    gs_windows_binary = False
+            gs_binary = gs_windows_binary
+        else:
+            try:
+                subprocess.check_call(["gs", "--version"], stdout=subprocess.DEVNULL)
+                gs_binary = "gs"
+            except OSError:
+                gs_binary = False
+    return gs_binary is not False
+
+
+def Ghostscript(
+    tile: list[ImageFile._Tile],
+    size: tuple[int, int],
+    fp: IO[bytes],
+    scale: int = 1,
+    transparency: bool = False,
+) -> Image.core.ImagingCore:
+    """Render an image using Ghostscript"""
+    global gs_binary
+    if not has_ghostscript():
+        msg = "Unable to locate Ghostscript on paths"
+        raise OSError(msg)
+    assert isinstance(gs_binary, str)
+
+    # Unpack decoder tile
+    args = tile[0].args
+    assert isinstance(args, tuple)
+    length, bbox = args
+
+    # Hack to support hi-res rendering
+    scale = int(scale) or 1
+    width = size[0] * scale
+    height = size[1] * scale
+    # resolution is dependent on bbox and size
+    res_x = 72.0 * width / (bbox[2] - bbox[0])
+    res_y = 72.0 * height / (bbox[3] - bbox[1])
+
+    out_fd, outfile = tempfile.mkstemp()
+    os.close(out_fd)
+
+    infile_temp = None
+    if hasattr(fp, "name") and os.path.exists(fp.name):
+        infile = fp.name
+    else:
+        in_fd, infile_temp = tempfile.mkstemp()
+        os.close(in_fd)
+        infile = infile_temp
+
+        # Ignore length and offset!
+        # Ghostscript can read it
+        # Copy whole file to read in Ghostscript
+        with open(infile_temp, "wb") as f:
+            # fetch length of fp
+            fp.seek(0, io.SEEK_END)
+            fsize = fp.tell()
+            # ensure start position
+            # go back
+            fp.seek(0)
+            lengthfile = fsize
+            while lengthfile > 0:
+                s = fp.read(min(lengthfile, 100 * 1024))
+                if not s:
+                    break
+                lengthfile -= len(s)
+                f.write(s)
+
+    if transparency:
+        # "RGBA"
+        device = "pngalpha"
+    else:
+        # "pnmraw" automatically chooses between
+        # PBM ("1"), PGM ("L"), and PPM ("RGB").
+        device = "pnmraw"
+
+    # Build Ghostscript command
+    command = [
+        gs_binary,
+        "-q",  # quiet mode
+        f"-g{width:d}x{height:d}",  # set output geometry (pixels)
+        f"-r{res_x:f}x{res_y:f}",  # set input DPI (dots per inch)
+        "-dBATCH",  # exit after processing
+        "-dNOPAUSE",  # don't pause between pages
+        "-dSAFER",  # safe mode
+        f"-sDEVICE={device}",
+        f"-sOutputFile={outfile}",  # output file
+        # adjust for image origin
+        "-c",
+        f"{-bbox[0]} {-bbox[1]} translate",
+        "-f",
+        infile,  # input file
+        # showpage (see https://bugs.ghostscript.com/show_bug.cgi?id=698272)
+        "-c",
+        "showpage",
+    ]
+
+    # push data through Ghostscript
+    try:
+        startupinfo = None
+        if sys.platform.startswith("win"):
+            startupinfo = subprocess.STARTUPINFO()
+            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        subprocess.check_call(command, startupinfo=startupinfo)
+        with Image.open(outfile) as out_im:
+            out_im.load()
+            return out_im.im.copy()
+    finally:
+        try:
+            os.unlink(outfile)
+            if infile_temp:
+                os.unlink(infile_temp)
+        except OSError:
+            pass
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix[:4] == b"%!PS" or (len(prefix) >= 4 and i32(prefix) == 0xC6D3D0C5)
+
+
+##
+# Image plugin for Encapsulated PostScript. This plugin supports only
+# a few variants of this format.
+
+
+class EpsImageFile(ImageFile.ImageFile):
+    """EPS File Parser for the Python Imaging Library"""
+
+    format = "EPS"
+    format_description = "Encapsulated Postscript"
+
+    mode_map = {1: "L", 2: "LAB", 3: "RGB", 4: "CMYK"}
+
+    def _open(self) -> None:
+        (length, offset) = self._find_offset(self.fp)
+
+        # go to offset - start of "%!PS"
+        self.fp.seek(offset)
+
+        self._mode = "RGB"
+
+        # When reading header comments, the first comment is used.
+        # When reading trailer comments, the last comment is used.
+        bounding_box: list[int] | None = None
+        imagedata_size: tuple[int, int] | None = None
+
+        byte_arr = bytearray(255)
+        bytes_mv = memoryview(byte_arr)
+        bytes_read = 0
+        reading_header_comments = True
+        reading_trailer_comments = False
+        trailer_reached = False
+
+        def check_required_header_comments() -> None:
+            """
+            The EPS specification requires that some headers exist.
+            This should be checked when the header comments formally end,
+            when image data starts, or when the file ends, whichever comes first.
+            """
+            if "PS-Adobe" not in self.info:
+                msg = 'EPS header missing "%!PS-Adobe" comment'
+                raise SyntaxError(msg)
+            if "BoundingBox" not in self.info:
+                msg = 'EPS header missing "%%BoundingBox" comment'
+                raise SyntaxError(msg)
+
+        def read_comment(s: str) -> bool:
+            nonlocal bounding_box, reading_trailer_comments
+            try:
+                m = split.match(s)
+            except re.error as e:
+                msg = "not an EPS file"
+                raise SyntaxError(msg) from e
+
+            if not m:
+                return False
+
+            k, v = m.group(1, 2)
+            self.info[k] = v
+            if k == "BoundingBox":
+                if v == "(atend)":
+                    reading_trailer_comments = True
+                elif not bounding_box or (trailer_reached and reading_trailer_comments):
+                    try:
+                        # Note: The DSC spec says that BoundingBox
+                        # fields should be integers, but some drivers
+                        # put floating point values there anyway.
+                        bounding_box = [int(float(i)) for i in v.split()]
+                    except Exception:
+                        pass
+            return True
+
+        while True:
+            byte = self.fp.read(1)
+            if byte == b"":
+                # if we didn't read a byte we must be at the end of the file
+                if bytes_read == 0:
+                    if reading_header_comments:
+                        check_required_header_comments()
+                    break
+            elif byte in b"\r\n":
+                # if we read a line ending character, ignore it and parse what
+                # we have already read. if we haven't read any other characters,
+                # continue reading
+                if bytes_read == 0:
+                    continue
+            else:
+                # ASCII/hexadecimal lines in an EPS file must not exceed
+                # 255 characters, not including line ending characters
+                if bytes_read >= 255:
+                    # only enforce this for lines starting with a "%",
+                    # otherwise assume it's binary data
+                    if byte_arr[0] == ord("%"):
+                        msg = "not an EPS file"
+                        raise SyntaxError(msg)
+                    else:
+                        if reading_header_comments:
+                            check_required_header_comments()
+                            reading_header_comments = False
+                        # reset bytes_read so we can keep reading
+                        # data until the end of the line
+                        bytes_read = 0
+                byte_arr[bytes_read] = byte[0]
+                bytes_read += 1
+                continue
+
+            if reading_header_comments:
+                # Load EPS header
+
+                # if this line doesn't start with a "%",
+                # or does start with "%%EndComments",
+                # then we've reached the end of the header/comments
+                if byte_arr[0] != ord("%") or bytes_mv[:13] == b"%%EndComments":
+                    check_required_header_comments()
+                    reading_header_comments = False
+                    continue
+
+                s = str(bytes_mv[:bytes_read], "latin-1")
+                if not read_comment(s):
+                    m = field.match(s)
+                    if m:
+                        k = m.group(1)
+                        if k[:8] == "PS-Adobe":
+                            self.info["PS-Adobe"] = k[9:]
+                        else:
+                            self.info[k] = ""
+                    elif s[0] == "%":
+                        # handle non-DSC PostScript comments that some
+                        # tools mistakenly put in the Comments section
+                        pass
+                    else:
+                        msg = "bad EPS header"
+                        raise OSError(msg)
+            elif bytes_mv[:11] == b"%ImageData:":
+                # Check for an "ImageData" descriptor
+                # https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#50577413_pgfId-1035096
+
+                # If we've already read an "ImageData" descriptor,
+                # don't read another one.
+                if imagedata_size:
+                    bytes_read = 0
+                    continue
+
+                # Values:
+                # columns
+                # rows
+                # bit depth (1 or 8)
+                # mode (1: L, 2: LAB, 3: RGB, 4: CMYK)
+                # number of padding channels
+                # block size (number of bytes per row per channel)
+                # binary/ascii (1: binary, 2: ascii)
+                # data start identifier (the image data follows after a single line
+                #   consisting only of this quoted value)
+                image_data_values = byte_arr[11:bytes_read].split(None, 7)
+                columns, rows, bit_depth, mode_id = (
+                    int(value) for value in image_data_values[:4]
+                )
+
+                if bit_depth == 1:
+                    self._mode = "1"
+                elif bit_depth == 8:
+                    try:
+                        self._mode = self.mode_map[mode_id]
+                    except ValueError:
+                        break
+                else:
+                    break
+
+                # Parse the columns and rows after checking the bit depth and mode
+                # in case the bit depth and/or mode are invalid.
+                imagedata_size = columns, rows
+            elif bytes_mv[:5] == b"%%EOF":
+                break
+            elif trailer_reached and reading_trailer_comments:
+                # Load EPS trailer
+                s = str(bytes_mv[:bytes_read], "latin-1")
+                read_comment(s)
+            elif bytes_mv[:9] == b"%%Trailer":
+                trailer_reached = True
+            bytes_read = 0
+
+        # A "BoundingBox" is always required,
+        # even if an "ImageData" descriptor size exists.
+        if not bounding_box:
+            msg = "cannot determine EPS bounding box"
+            raise OSError(msg)
+
+        # An "ImageData" size takes precedence over the "BoundingBox".
+        self._size = imagedata_size or (
+            bounding_box[2] - bounding_box[0],
+            bounding_box[3] - bounding_box[1],
+        )
+
+        self.tile = [
+            ImageFile._Tile("eps", (0, 0) + self.size, offset, (length, bounding_box))
+        ]
+
+    def _find_offset(self, fp: IO[bytes]) -> tuple[int, int]:
+        s = fp.read(4)
+
+        if s == b"%!PS":
+            # for HEAD without binary preview
+            fp.seek(0, io.SEEK_END)
+            length = fp.tell()
+            offset = 0
+        elif i32(s) == 0xC6D3D0C5:
+            # FIX for: Some EPS file not handled correctly / issue #302
+            # EPS can contain binary data
+            # or start directly with latin coding
+            # more info see:
+            # https://web.archive.org/web/20160528181353/http://partners.adobe.com/public/developer/en/ps/5002.EPSF_Spec.pdf
+            s = fp.read(8)
+            offset = i32(s)
+            length = i32(s, 4)
+        else:
+            msg = "not an EPS file"
+            raise SyntaxError(msg)
+
+        return length, offset
+
+    def load(
+        self, scale: int = 1, transparency: bool = False
+    ) -> Image.core.PixelAccess | None:
+        # Load EPS via Ghostscript
+        if self.tile:
+            self.im = Ghostscript(self.tile, self.size, self.fp, scale, transparency)
+            self._mode = self.im.mode
+            self._size = self.im.size
+            self.tile = []
+        return Image.Image.load(self)
+
+    def load_seek(self, pos: int) -> None:
+        # we can't incrementally load, so force ImageFile.parser to
+        # use our custom load method by defining this method.
+        pass
+
+
+# --------------------------------------------------------------------
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes, eps: int = 1) -> None:
+    """EPS Writer for the Python Imaging Library."""
+
+    # make sure image data is available
+    im.load()
+
+    # determine PostScript image mode
+    if im.mode == "L":
+        operator = (8, 1, b"image")
+    elif im.mode == "RGB":
+        operator = (8, 3, b"false 3 colorimage")
+    elif im.mode == "CMYK":
+        operator = (8, 4, b"false 4 colorimage")
+    else:
+        msg = "image mode is not supported"
+        raise ValueError(msg)
+
+    if eps:
+        # write EPS header
+        fp.write(b"%!PS-Adobe-3.0 EPSF-3.0\n")
+        fp.write(b"%%Creator: PIL 0.1 EpsEncode\n")
+        # fp.write("%%CreationDate: %s"...)
+        fp.write(b"%%%%BoundingBox: 0 0 %d %d\n" % im.size)
+        fp.write(b"%%Pages: 1\n")
+        fp.write(b"%%EndComments\n")
+        fp.write(b"%%Page: 1 1\n")
+        fp.write(b"%%ImageData: %d %d " % im.size)
+        fp.write(b'%d %d 0 1 1 "%s"\n' % operator)
+
+    # image header
+    fp.write(b"gsave\n")
+    fp.write(b"10 dict begin\n")
+    fp.write(b"/buf %d string def\n" % (im.size[0] * operator[1]))
+    fp.write(b"%d %d scale\n" % im.size)
+    fp.write(b"%d %d 8\n" % im.size)  # <= bits
+    fp.write(b"[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1], im.size[1]))
+    fp.write(b"{ currentfile buf readhexstring pop } bind\n")
+    fp.write(operator[2] + b"\n")
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+    ImageFile._save(im, fp, [ImageFile._Tile("eps", (0, 0) + im.size, 0, None)])
+
+    fp.write(b"\n%%%%EndBinary\n")
+    fp.write(b"grestore end\n")
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+# --------------------------------------------------------------------
+
+
+Image.register_open(EpsImageFile.format, EpsImageFile, _accept)
+
+Image.register_save(EpsImageFile.format, _save)
+
+Image.register_extensions(EpsImageFile.format, [".ps", ".eps"])
+
+Image.register_mime(EpsImageFile.format, "application/postscript")

src/venv/Lib/site-packages/PIL/ExifTags.py

@@ -0,0 +1,381 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# EXIF tags
+#
+# Copyright (c) 2003 by Secret Labs AB
+#
+# See the README file for information on usage and redistribution.
+#
+
+"""
+This module provides constants and clear-text names for various
+well-known EXIF tags.
+"""
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class Base(IntEnum):
+    # possibly incomplete
+    InteropIndex = 0x0001
+    ProcessingSoftware = 0x000B
+    NewSubfileType = 0x00FE
+    SubfileType = 0x00FF
+    ImageWidth = 0x0100
+    ImageLength = 0x0101
+    BitsPerSample = 0x0102
+    Compression = 0x0103
+    PhotometricInterpretation = 0x0106
+    Thresholding = 0x0107
+    CellWidth = 0x0108
+    CellLength = 0x0109
+    FillOrder = 0x010A
+    DocumentName = 0x010D
+    ImageDescription = 0x010E
+    Make = 0x010F
+    Model = 0x0110
+    StripOffsets = 0x0111
+    Orientation = 0x0112
+    SamplesPerPixel = 0x0115
+    RowsPerStrip = 0x0116
+    StripByteCounts = 0x0117
+    MinSampleValue = 0x0118
+    MaxSampleValue = 0x0119
+    XResolution = 0x011A
+    YResolution = 0x011B
+    PlanarConfiguration = 0x011C
+    PageName = 0x011D
+    FreeOffsets = 0x0120
+    FreeByteCounts = 0x0121
+    GrayResponseUnit = 0x0122
+    GrayResponseCurve = 0x0123
+    T4Options = 0x0124
+    T6Options = 0x0125
+    ResolutionUnit = 0x0128
+    PageNumber = 0x0129
+    TransferFunction = 0x012D
+    Software = 0x0131
+    DateTime = 0x0132
+    Artist = 0x013B
+    HostComputer = 0x013C
+    Predictor = 0x013D
+    WhitePoint = 0x013E
+    PrimaryChromaticities = 0x013F
+    ColorMap = 0x0140
+    HalftoneHints = 0x0141
+    TileWidth = 0x0142
+    TileLength = 0x0143
+    TileOffsets = 0x0144
+    TileByteCounts = 0x0145
+    SubIFDs = 0x014A
+    InkSet = 0x014C
+    InkNames = 0x014D
+    NumberOfInks = 0x014E
+    DotRange = 0x0150
+    TargetPrinter = 0x0151
+    ExtraSamples = 0x0152
+    SampleFormat = 0x0153
+    SMinSampleValue = 0x0154
+    SMaxSampleValue = 0x0155
+    TransferRange = 0x0156
+    ClipPath = 0x0157
+    XClipPathUnits = 0x0158
+    YClipPathUnits = 0x0159
+    Indexed = 0x015A
+    JPEGTables = 0x015B
+    OPIProxy = 0x015F
+    JPEGProc = 0x0200
+    JpegIFOffset = 0x0201
+    JpegIFByteCount = 0x0202
+    JpegRestartInterval = 0x0203
+    JpegLosslessPredictors = 0x0205
+    JpegPointTransforms = 0x0206
+    JpegQTables = 0x0207
+    JpegDCTables = 0x0208
+    JpegACTables = 0x0209
+    YCbCrCoefficients = 0x0211
+    YCbCrSubSampling = 0x0212
+    YCbCrPositioning = 0x0213
+    ReferenceBlackWhite = 0x0214
+    XMLPacket = 0x02BC
+    RelatedImageFileFormat = 0x1000
+    RelatedImageWidth = 0x1001
+    RelatedImageLength = 0x1002
+    Rating = 0x4746
+    RatingPercent = 0x4749
+    ImageID = 0x800D
+    CFARepeatPatternDim = 0x828D
+    BatteryLevel = 0x828F
+    Copyright = 0x8298
+    ExposureTime = 0x829A
+    FNumber = 0x829D
+    IPTCNAA = 0x83BB
+    ImageResources = 0x8649
+    ExifOffset = 0x8769
+    InterColorProfile = 0x8773
+    ExposureProgram = 0x8822
+    SpectralSensitivity = 0x8824
+    GPSInfo = 0x8825
+    ISOSpeedRatings = 0x8827
+    OECF = 0x8828
+    Interlace = 0x8829
+    TimeZoneOffset = 0x882A
+    SelfTimerMode = 0x882B
+    SensitivityType = 0x8830
+    StandardOutputSensitivity = 0x8831
+    RecommendedExposureIndex = 0x8832
+    ISOSpeed = 0x8833
+    ISOSpeedLatitudeyyy = 0x8834
+    ISOSpeedLatitudezzz = 0x8835
+    ExifVersion = 0x9000
+    DateTimeOriginal = 0x9003
+    DateTimeDigitized = 0x9004
+    OffsetTime = 0x9010
+    OffsetTimeOriginal = 0x9011
+    OffsetTimeDigitized = 0x9012
+    ComponentsConfiguration = 0x9101
+    CompressedBitsPerPixel = 0x9102
+    ShutterSpeedValue = 0x9201
+    ApertureValue = 0x9202
+    BrightnessValue = 0x9203
+    ExposureBiasValue = 0x9204
+    MaxApertureValue = 0x9205
+    SubjectDistance = 0x9206
+    MeteringMode = 0x9207
+    LightSource = 0x9208
+    Flash = 0x9209
+    FocalLength = 0x920A
+    Noise = 0x920D
+    ImageNumber = 0x9211
+    SecurityClassification = 0x9212
+    ImageHistory = 0x9213
+    TIFFEPStandardID = 0x9216
+    MakerNote = 0x927C
+    UserComment = 0x9286
+    SubsecTime = 0x9290
+    SubsecTimeOriginal = 0x9291
+    SubsecTimeDigitized = 0x9292
+    AmbientTemperature = 0x9400
+    Humidity = 0x9401
+    Pressure = 0x9402
+    WaterDepth = 0x9403
+    Acceleration = 0x9404
+    CameraElevationAngle = 0x9405
+    XPTitle = 0x9C9B
+    XPComment = 0x9C9C
+    XPAuthor = 0x9C9D
+    XPKeywords = 0x9C9E
+    XPSubject = 0x9C9F
+    FlashPixVersion = 0xA000
+    ColorSpace = 0xA001
+    ExifImageWidth = 0xA002
+    ExifImageHeight = 0xA003
+    RelatedSoundFile = 0xA004
+    ExifInteroperabilityOffset = 0xA005
+    FlashEnergy = 0xA20B
+    SpatialFrequencyResponse = 0xA20C
+    FocalPlaneXResolution = 0xA20E
+    FocalPlaneYResolution = 0xA20F
+    FocalPlaneResolutionUnit = 0xA210
+    SubjectLocation = 0xA214
+    ExposureIndex = 0xA215
+    SensingMethod = 0xA217
+    FileSource = 0xA300
+    SceneType = 0xA301
+    CFAPattern = 0xA302
+    CustomRendered = 0xA401
+    ExposureMode = 0xA402
+    WhiteBalance = 0xA403
+    DigitalZoomRatio = 0xA404
+    FocalLengthIn35mmFilm = 0xA405
+    SceneCaptureType = 0xA406
+    GainControl = 0xA407
+    Contrast = 0xA408
+    Saturation = 0xA409
+    Sharpness = 0xA40A
+    DeviceSettingDescription = 0xA40B
+    SubjectDistanceRange = 0xA40C
+    ImageUniqueID = 0xA420
+    CameraOwnerName = 0xA430
+    BodySerialNumber = 0xA431
+    LensSpecification = 0xA432
+    LensMake = 0xA433
+    LensModel = 0xA434
+    LensSerialNumber = 0xA435
+    CompositeImage = 0xA460
+    CompositeImageCount = 0xA461
+    CompositeImageExposureTimes = 0xA462
+    Gamma = 0xA500
+    PrintImageMatching = 0xC4A5
+    DNGVersion = 0xC612
+    DNGBackwardVersion = 0xC613
+    UniqueCameraModel = 0xC614
+    LocalizedCameraModel = 0xC615
+    CFAPlaneColor = 0xC616
+    CFALayout = 0xC617
+    LinearizationTable = 0xC618
+    BlackLevelRepeatDim = 0xC619
+    BlackLevel = 0xC61A
+    BlackLevelDeltaH = 0xC61B
+    BlackLevelDeltaV = 0xC61C
+    WhiteLevel = 0xC61D
+    DefaultScale = 0xC61E
+    DefaultCropOrigin = 0xC61F
+    DefaultCropSize = 0xC620
+    ColorMatrix1 = 0xC621
+    ColorMatrix2 = 0xC622
+    CameraCalibration1 = 0xC623
+    CameraCalibration2 = 0xC624
+    ReductionMatrix1 = 0xC625
+    ReductionMatrix2 = 0xC626
+    AnalogBalance = 0xC627
+    AsShotNeutral = 0xC628
+    AsShotWhiteXY = 0xC629
+    BaselineExposure = 0xC62A
+    BaselineNoise = 0xC62B
+    BaselineSharpness = 0xC62C
+    BayerGreenSplit = 0xC62D
+    LinearResponseLimit = 0xC62E
+    CameraSerialNumber = 0xC62F
+    LensInfo = 0xC630
+    ChromaBlurRadius = 0xC631
+    AntiAliasStrength = 0xC632
+    ShadowScale = 0xC633
+    DNGPrivateData = 0xC634
+    MakerNoteSafety = 0xC635
+    CalibrationIlluminant1 = 0xC65A
+    CalibrationIlluminant2 = 0xC65B
+    BestQualityScale = 0xC65C
+    RawDataUniqueID = 0xC65D
+    OriginalRawFileName = 0xC68B
+    OriginalRawFileData = 0xC68C
+    ActiveArea = 0xC68D
+    MaskedAreas = 0xC68E
+    AsShotICCProfile = 0xC68F
+    AsShotPreProfileMatrix = 0xC690
+    CurrentICCProfile = 0xC691
+    CurrentPreProfileMatrix = 0xC692
+    ColorimetricReference = 0xC6BF
+    CameraCalibrationSignature = 0xC6F3
+    ProfileCalibrationSignature = 0xC6F4
+    AsShotProfileName = 0xC6F6
+    NoiseReductionApplied = 0xC6F7
+    ProfileName = 0xC6F8
+    ProfileHueSatMapDims = 0xC6F9
+    ProfileHueSatMapData1 = 0xC6FA
+    ProfileHueSatMapData2 = 0xC6FB
+    ProfileToneCurve = 0xC6FC
+    ProfileEmbedPolicy = 0xC6FD
+    ProfileCopyright = 0xC6FE
+    ForwardMatrix1 = 0xC714
+    ForwardMatrix2 = 0xC715
+    PreviewApplicationName = 0xC716
+    PreviewApplicationVersion = 0xC717
+    PreviewSettingsName = 0xC718
+    PreviewSettingsDigest = 0xC719
+    PreviewColorSpace = 0xC71A
+    PreviewDateTime = 0xC71B
+    RawImageDigest = 0xC71C
+    OriginalRawFileDigest = 0xC71D
+    SubTileBlockSize = 0xC71E
+    RowInterleaveFactor = 0xC71F
+    ProfileLookTableDims = 0xC725
+    ProfileLookTableData = 0xC726
+    OpcodeList1 = 0xC740
+    OpcodeList2 = 0xC741
+    OpcodeList3 = 0xC74E
+    NoiseProfile = 0xC761
+
+
+"""Maps EXIF tags to tag names."""
+TAGS = {
+    **{i.value: i.name for i in Base},
+    0x920C: "SpatialFrequencyResponse",
+    0x9214: "SubjectLocation",
+    0x9215: "ExposureIndex",
+    0x828E: "CFAPattern",
+    0x920B: "FlashEnergy",
+    0x9216: "TIFF/EPStandardID",
+}
+
+
+class GPS(IntEnum):
+    GPSVersionID = 0
+    GPSLatitudeRef = 1
+    GPSLatitude = 2
+    GPSLongitudeRef = 3
+    GPSLongitude = 4
+    GPSAltitudeRef = 5
+    GPSAltitude = 6
+    GPSTimeStamp = 7
+    GPSSatellites = 8
+    GPSStatus = 9
+    GPSMeasureMode = 10
+    GPSDOP = 11
+    GPSSpeedRef = 12
+    GPSSpeed = 13
+    GPSTrackRef = 14
+    GPSTrack = 15
+    GPSImgDirectionRef = 16
+    GPSImgDirection = 17
+    GPSMapDatum = 18
+    GPSDestLatitudeRef = 19
+    GPSDestLatitude = 20
+    GPSDestLongitudeRef = 21
+    GPSDestLongitude = 22
+    GPSDestBearingRef = 23
+    GPSDestBearing = 24
+    GPSDestDistanceRef = 25
+    GPSDestDistance = 26
+    GPSProcessingMethod = 27
+    GPSAreaInformation = 28
+    GPSDateStamp = 29
+    GPSDifferential = 30
+    GPSHPositioningError = 31
+
+
+"""Maps EXIF GPS tags to tag names."""
+GPSTAGS = {i.value: i.name for i in GPS}
+
+
+class Interop(IntEnum):
+    InteropIndex = 1
+    InteropVersion = 2
+    RelatedImageFileFormat = 4096
+    RelatedImageWidth = 4097
+    RelatedImageHeight = 4098
+
+
+class IFD(IntEnum):
+    Exif = 34665
+    GPSInfo = 34853
+    Makernote = 37500
+    Interop = 40965
+    IFD1 = -1
+
+
+class LightSource(IntEnum):
+    Unknown = 0
+    Daylight = 1
+    Fluorescent = 2
+    Tungsten = 3
+    Flash = 4
+    Fine = 9
+    Cloudy = 10
+    Shade = 11
+    DaylightFluorescent = 12
+    DayWhiteFluorescent = 13
+    CoolWhiteFluorescent = 14
+    WhiteFluorescent = 15
+    StandardLightA = 17
+    StandardLightB = 18
+    StandardLightC = 19
+    D55 = 20
+    D65 = 21
+    D75 = 22
+    D50 = 23
+    ISO = 24
+    Other = 255

src/venv/Lib/site-packages/PIL/FitsImagePlugin.py

@@ -0,0 +1,152 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# FITS file handling
+#
+# Copyright (c) 1998-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import gzip
+import math
+
+from . import Image, ImageFile
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix[:6] == b"SIMPLE"
+
+
+class FitsImageFile(ImageFile.ImageFile):
+    format = "FITS"
+    format_description = "FITS"
+
+    def _open(self) -> None:
+        assert self.fp is not None
+
+        headers: dict[bytes, bytes] = {}
+        header_in_progress = False
+        decoder_name = ""
+        while True:
+            header = self.fp.read(80)
+            if not header:
+                msg = "Truncated FITS file"
+                raise OSError(msg)
+            keyword = header[:8].strip()
+            if keyword in (b"SIMPLE", b"XTENSION"):
+                header_in_progress = True
+            elif headers and not header_in_progress:
+                # This is now a data unit
+                break
+            elif keyword == b"END":
+                # Seek to the end of the header unit
+                self.fp.seek(math.ceil(self.fp.tell() / 2880) * 2880)
+                if not decoder_name:
+                    decoder_name, offset, args = self._parse_headers(headers)
+
+                header_in_progress = False
+                continue
+
+            if decoder_name:
+                # Keep going to read past the headers
+                continue
+
+            value = header[8:].split(b"/")[0].strip()
+            if value.startswith(b"="):
+                value = value[1:].strip()
+            if not headers and (not _accept(keyword) or value != b"T"):
+                msg = "Not a FITS file"
+                raise SyntaxError(msg)
+            headers[keyword] = value
+
+        if not decoder_name:
+            msg = "No image data"
+            raise ValueError(msg)
+
+        offset += self.fp.tell() - 80
+        self.tile = [ImageFile._Tile(decoder_name, (0, 0) + self.size, offset, args)]
+
+    def _get_size(
+        self, headers: dict[bytes, bytes], prefix: bytes
+    ) -> tuple[int, int] | None:
+        naxis = int(headers[prefix + b"NAXIS"])
+        if naxis == 0:
+            return None
+
+        if naxis == 1:
+            return 1, int(headers[prefix + b"NAXIS1"])
+        else:
+            return int(headers[prefix + b"NAXIS1"]), int(headers[prefix + b"NAXIS2"])
+
+    def _parse_headers(
+        self, headers: dict[bytes, bytes]
+    ) -> tuple[str, int, tuple[str | int, ...]]:
+        prefix = b""
+        decoder_name = "raw"
+        offset = 0
+        if (
+            headers.get(b"XTENSION") == b"'BINTABLE'"
+            and headers.get(b"ZIMAGE") == b"T"
+            and headers[b"ZCMPTYPE"] == b"'GZIP_1  '"
+        ):
+            no_prefix_size = self._get_size(headers, prefix) or (0, 0)
+            number_of_bits = int(headers[b"BITPIX"])
+            offset = no_prefix_size[0] * no_prefix_size[1] * (number_of_bits // 8)
+
+            prefix = b"Z"
+            decoder_name = "fits_gzip"
+
+        size = self._get_size(headers, prefix)
+        if not size:
+            return "", 0, ()
+
+        self._size = size
+
+        number_of_bits = int(headers[prefix + b"BITPIX"])
+        if number_of_bits == 8:
+            self._mode = "L"
+        elif number_of_bits == 16:
+            self._mode = "I;16"
+        elif number_of_bits == 32:
+            self._mode = "I"
+        elif number_of_bits in (-32, -64):
+            self._mode = "F"
+
+        args: tuple[str | int, ...]
+        if decoder_name == "raw":
+            args = (self.mode, 0, -1)
+        else:
+            args = (number_of_bits,)
+        return decoder_name, offset, args
+
+
+class FitsGzipDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
+        assert self.fd is not None
+        value = gzip.decompress(self.fd.read())
+
+        rows = []
+        offset = 0
+        number_of_bits = min(self.args[0] // 8, 4)
+        for y in range(self.state.ysize):
+            row = bytearray()
+            for x in range(self.state.xsize):
+                row += value[offset + (4 - number_of_bits) : offset + 4]
+                offset += 4
+            rows.append(row)
+        self.set_as_raw(bytes([pixel for row in rows[::-1] for pixel in row]))
+        return -1, 0
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(FitsImageFile.format, FitsImageFile, _accept)
+Image.register_decoder("fits_gzip", FitsGzipDecoder)
+
+Image.register_extensions(FitsImageFile.format, [".fit", ".fits"])

src/venv/Lib/site-packages/PIL/FliImagePlugin.py

@@ -0,0 +1,175 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# FLI/FLC file handling.
+#
+# History:
+#       95-09-01 fl     Created
+#       97-01-03 fl     Fixed parser, setup decoder tile
+#       98-07-15 fl     Renamed offset attribute to avoid name clash
+#
+# Copyright (c) Secret Labs AB 1997-98.
+# Copyright (c) Fredrik Lundh 1995-97.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+from ._binary import o8
+
+#
+# decoder
+
+
+def _accept(prefix: bytes) -> bool:
+    return (
+        len(prefix) >= 6
+        and i16(prefix, 4) in [0xAF11, 0xAF12]
+        and i16(prefix, 14) in [0, 3]  # flags
+    )
+
+
+##
+# Image plugin for the FLI/FLC animation format.  Use the <b>seek</b>
+# method to load individual frames.
+
+
+class FliImageFile(ImageFile.ImageFile):
+    format = "FLI"
+    format_description = "Autodesk FLI/FLC Animation"
+    _close_exclusive_fp_after_loading = False
+
+    def _open(self) -> None:
+        # HEAD
+        s = self.fp.read(128)
+        if not (_accept(s) and s[20:22] == b"\x00\x00"):
+            msg = "not an FLI/FLC file"
+            raise SyntaxError(msg)
+
+        # frames
+        self.n_frames = i16(s, 6)
+        self.is_animated = self.n_frames > 1
+
+        # image characteristics
+        self._mode = "P"
+        self._size = i16(s, 8), i16(s, 10)
+
+        # animation speed
+        duration = i32(s, 16)
+        magic = i16(s, 4)
+        if magic == 0xAF11:
+            duration = (duration * 1000) // 70
+        self.info["duration"] = duration
+
+        # look for palette
+        palette = [(a, a, a) for a in range(256)]
+
+        s = self.fp.read(16)
+
+        self.__offset = 128
+
+        if i16(s, 4) == 0xF100:
+            # prefix chunk; ignore it
+            self.__offset = self.__offset + i32(s)
+            self.fp.seek(self.__offset)
+            s = self.fp.read(16)
+
+        if i16(s, 4) == 0xF1FA:
+            # look for palette chunk
+            number_of_subchunks = i16(s, 6)
+            chunk_size: int | None = None
+            for _ in range(number_of_subchunks):
+                if chunk_size is not None:
+                    self.fp.seek(chunk_size - 6, os.SEEK_CUR)
+                s = self.fp.read(6)
+                chunk_type = i16(s, 4)
+                if chunk_type in (4, 11):
+                    self._palette(palette, 2 if chunk_type == 11 else 0)
+                    break
+                chunk_size = i32(s)
+                if not chunk_size:
+                    break
+
+        self.palette = ImagePalette.raw(
+            "RGB", b"".join(o8(r) + o8(g) + o8(b) for (r, g, b) in palette)
+        )
+
+        # set things up to decode first frame
+        self.__frame = -1
+        self._fp = self.fp
+        self.__rewind = self.fp.tell()
+        self.seek(0)
+
+    def _palette(self, palette: list[tuple[int, int, int]], shift: int) -> None:
+        # load palette
+
+        i = 0
+        for e in range(i16(self.fp.read(2))):
+            s = self.fp.read(2)
+            i = i + s[0]
+            n = s[1]
+            if n == 0:
+                n = 256
+            s = self.fp.read(n * 3)
+            for n in range(0, len(s), 3):
+                r = s[n] << shift
+                g = s[n + 1] << shift
+                b = s[n + 2] << shift
+                palette[i] = (r, g, b)
+                i += 1
+
+    def seek(self, frame: int) -> None:
+        if not self._seek_check(frame):
+            return
+        if frame < self.__frame:
+            self._seek(0)
+
+        for f in range(self.__frame + 1, frame + 1):
+            self._seek(f)
+
+    def _seek(self, frame: int) -> None:
+        if frame == 0:
+            self.__frame = -1
+            self._fp.seek(self.__rewind)
+            self.__offset = 128
+        else:
+            # ensure that the previous frame was loaded
+            self.load()
+
+        if frame != self.__frame + 1:
+            msg = f"cannot seek to frame {frame}"
+            raise ValueError(msg)
+        self.__frame = frame
+
+        # move to next frame
+        self.fp = self._fp
+        self.fp.seek(self.__offset)
+
+        s = self.fp.read(4)
+        if not s:
+            msg = "missing frame size"
+            raise EOFError(msg)
+
+        framesize = i32(s)
+
+        self.decodermaxblock = framesize
+        self.tile = [ImageFile._Tile("fli", (0, 0) + self.size, self.__offset, None)]
+
+        self.__offset += framesize
+
+    def tell(self) -> int:
+        return self.__frame
+
+
+#
+# registry
+
+Image.register_open(FliImageFile.format, FliImageFile, _accept)
+
+Image.register_extensions(FliImageFile.format, [".fli", ".flc"])

src/venv/Lib/site-packages/PIL/FontFile.py

@@ -0,0 +1,134 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# base class for raster font file parsers
+#
+# history:
+# 1997-06-05 fl   created
+# 1997-08-19 fl   restrict image width
+#
+# Copyright (c) 1997-1998 by Secret Labs AB
+# Copyright (c) 1997-1998 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+from typing import BinaryIO
+
+from . import Image, _binary
+
+WIDTH = 800
+
+
+def puti16(
+    fp: BinaryIO, values: tuple[int, int, int, int, int, int, int, int, int, int]
+) -> None:
+    """Write network order (big-endian) 16-bit sequence"""
+    for v in values:
+        if v < 0:
+            v += 65536
+        fp.write(_binary.o16be(v))
+
+
+class FontFile:
+    """Base class for raster font file handlers."""
+
+    bitmap: Image.Image | None = None
+
+    def __init__(self) -> None:
+        self.info: dict[bytes, bytes | int] = {}
+        self.glyph: list[
+            tuple[
+                tuple[int, int],
+                tuple[int, int, int, int],
+                tuple[int, int, int, int],
+                Image.Image,
+            ]
+            | None
+        ] = [None] * 256
+
+    def __getitem__(self, ix: int) -> (
+        tuple[
+            tuple[int, int],
+            tuple[int, int, int, int],
+            tuple[int, int, int, int],
+            Image.Image,
+        ]
+        | None
+    ):
+        return self.glyph[ix]
+
+    def compile(self) -> None:
+        """Create metrics and bitmap"""
+
+        if self.bitmap:
+            return
+
+        # create bitmap large enough to hold all data
+        h = w = maxwidth = 0
+        lines = 1
+        for glyph in self.glyph:
+            if glyph:
+                d, dst, src, im = glyph
+                h = max(h, src[3] - src[1])
+                w = w + (src[2] - src[0])
+                if w > WIDTH:
+                    lines += 1
+                    w = src[2] - src[0]
+                maxwidth = max(maxwidth, w)
+
+        xsize = maxwidth
+        ysize = lines * h
+
+        if xsize == 0 and ysize == 0:
+            return
+
+        self.ysize = h
+
+        # paste glyphs into bitmap
+        self.bitmap = Image.new("1", (xsize, ysize))
+        self.metrics: list[
+            tuple[tuple[int, int], tuple[int, int, int, int], tuple[int, int, int, int]]
+            | None
+        ] = [None] * 256
+        x = y = 0
+        for i in range(256):
+            glyph = self[i]
+            if glyph:
+                d, dst, src, im = glyph
+                xx = src[2] - src[0]
+                x0, y0 = x, y
+                x = x + xx
+                if x > WIDTH:
+                    x, y = 0, y + h
+                    x0, y0 = x, y
+                    x = xx
+                s = src[0] + x0, src[1] + y0, src[2] + x0, src[3] + y0
+                self.bitmap.paste(im.crop(src), s)
+                self.metrics[i] = d, dst, s
+
+    def save(self, filename: str) -> None:
+        """Save font"""
+
+        self.compile()
+
+        # font data
+        if not self.bitmap:
+            msg = "No bitmap created"
+            raise ValueError(msg)
+        self.bitmap.save(os.path.splitext(filename)[0] + ".pbm", "PNG")
+
+        # font metrics
+        with open(os.path.splitext(filename)[0] + ".pil", "wb") as fp:
+            fp.write(b"PILfont\n")
+            fp.write(f";;;;;;{self.ysize};\n".encode("ascii"))  # HACK!!!
+            fp.write(b"DATA\n")
+            for id in range(256):
+                m = self.metrics[id]
+                if not m:
+                    puti16(fp, (0,) * 10)
+                else:
+                    puti16(fp, m[0] + m[1] + m[2])

src/venv/Lib/site-packages/PIL/FpxImagePlugin.py

@@ -0,0 +1,257 @@
+#
+# THIS IS WORK IN PROGRESS
+#
+# The Python Imaging Library.
+# $Id$
+#
+# FlashPix support for PIL
+#
+# History:
+# 97-01-25 fl   Created (reads uncompressed RGB images only)
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1997.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import olefile
+
+from . import Image, ImageFile
+from ._binary import i32le as i32
+
+# we map from colour field tuples to (mode, rawmode) descriptors
+MODES = {
+    # opacity
+    (0x00007FFE,): ("A", "L"),
+    # monochrome
+    (0x00010000,): ("L", "L"),
+    (0x00018000, 0x00017FFE): ("RGBA", "LA"),
+    # photo YCC
+    (0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"),
+    (0x00028000, 0x00028001, 0x00028002, 0x00027FFE): ("RGBA", "YCCA;P"),
+    # standard RGB (NIFRGB)
+    (0x00030000, 0x00030001, 0x00030002): ("RGB", "RGB"),
+    (0x00038000, 0x00038001, 0x00038002, 0x00037FFE): ("RGBA", "RGBA"),
+}
+
+
+#
+# --------------------------------------------------------------------
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix[:8] == olefile.MAGIC
+
+
+##
+# Image plugin for the FlashPix images.
+
+
+class FpxImageFile(ImageFile.ImageFile):
+    format = "FPX"
+    format_description = "FlashPix"
+
+    def _open(self) -> None:
+        #
+        # read the OLE directory and see if this is a likely
+        # to be a FlashPix file
+
+        try:
+            self.ole = olefile.OleFileIO(self.fp)
+        except OSError as e:
+            msg = "not an FPX file; invalid OLE file"
+            raise SyntaxError(msg) from e
+
+        root = self.ole.root
+        if not root or root.clsid != "56616700-C154-11CE-8553-00AA00A1F95B":
+            msg = "not an FPX file; bad root CLSID"
+            raise SyntaxError(msg)
+
+        self._open_index(1)
+
+    def _open_index(self, index: int = 1) -> None:
+        #
+        # get the Image Contents Property Set
+
+        prop = self.ole.getproperties(
+            [f"Data Object Store {index:06d}", "\005Image Contents"]
+        )
+
+        # size (highest resolution)
+
+        assert isinstance(prop[0x1000002], int)
+        assert isinstance(prop[0x1000003], int)
+        self._size = prop[0x1000002], prop[0x1000003]
+
+        size = max(self.size)
+        i = 1
+        while size > 64:
+            size = size // 2
+            i += 1
+        self.maxid = i - 1
+
+        # mode.  instead of using a single field for this, flashpix
+        # requires you to specify the mode for each channel in each
+        # resolution subimage, and leaves it to the decoder to make
+        # sure that they all match.  for now, we'll cheat and assume
+        # that this is always the case.
+
+        id = self.maxid << 16
+
+        s = prop[0x2000002 | id]
+
+        if not isinstance(s, bytes) or (bands := i32(s, 4)) > 4:
+            msg = "Invalid number of bands"
+            raise OSError(msg)
+
+        # note: for now, we ignore the "uncalibrated" flag
+        colors = tuple(i32(s, 8 + i * 4) & 0x7FFFFFFF for i in range(bands))
+
+        self._mode, self.rawmode = MODES[colors]
+
+        # load JPEG tables, if any
+        self.jpeg = {}
+        for i in range(256):
+            id = 0x3000001 | (i << 16)
+            if id in prop:
+                self.jpeg[i] = prop[id]
+
+        self._open_subimage(1, self.maxid)
+
+    def _open_subimage(self, index: int = 1, subimage: int = 0) -> None:
+        #
+        # setup tile descriptors for a given subimage
+
+        stream = [
+            f"Data Object Store {index:06d}",
+            f"Resolution {subimage:04d}",
+            "Subimage 0000 Header",
+        ]
+
+        fp = self.ole.openstream(stream)
+
+        # skip prefix
+        fp.read(28)
+
+        # header stream
+        s = fp.read(36)
+
+        size = i32(s, 4), i32(s, 8)
+        # tilecount = i32(s, 12)
+        tilesize = i32(s, 16), i32(s, 20)
+        # channels = i32(s, 24)
+        offset = i32(s, 28)
+        length = i32(s, 32)
+
+        if size != self.size:
+            msg = "subimage mismatch"
+            raise OSError(msg)
+
+        # get tile descriptors
+        fp.seek(28 + offset)
+        s = fp.read(i32(s, 12) * length)
+
+        x = y = 0
+        xsize, ysize = size
+        xtile, ytile = tilesize
+        self.tile = []
+
+        for i in range(0, len(s), length):
+            x1 = min(xsize, x + xtile)
+            y1 = min(ysize, y + ytile)
+
+            compression = i32(s, i + 8)
+
+            if compression == 0:
+                self.tile.append(
+                    ImageFile._Tile(
+                        "raw",
+                        (x, y, x1, y1),
+                        i32(s, i) + 28,
+                        (self.rawmode,),
+                    )
+                )
+
+            elif compression == 1:
+                # FIXME: the fill decoder is not implemented
+                self.tile.append(
+                    ImageFile._Tile(
+                        "fill",
+                        (x, y, x1, y1),
+                        i32(s, i) + 28,
+                        (self.rawmode, s[12:16]),
+                    )
+                )
+
+            elif compression == 2:
+                internal_color_conversion = s[14]
+                jpeg_tables = s[15]
+                rawmode = self.rawmode
+
+                if internal_color_conversion:
+                    # The image is stored as usual (usually YCbCr).
+                    if rawmode == "RGBA":
+                        # For "RGBA", data is stored as YCbCrA based on
+                        # negative RGB. The following trick works around
+                        # this problem :
+                        jpegmode, rawmode = "YCbCrK", "CMYK"
+                    else:
+                        jpegmode = None  # let the decoder decide
+
+                else:
+                    # The image is stored as defined by rawmode
+                    jpegmode = rawmode
+
+                self.tile.append(
+                    ImageFile._Tile(
+                        "jpeg",
+                        (x, y, x1, y1),
+                        i32(s, i) + 28,
+                        (rawmode, jpegmode),
+                    )
+                )
+
+                # FIXME: jpeg tables are tile dependent; the prefix
+                # data must be placed in the tile descriptor itself!
+
+                if jpeg_tables:
+                    self.tile_prefix = self.jpeg[jpeg_tables]
+
+            else:
+                msg = "unknown/invalid compression"
+                raise OSError(msg)
+
+            x = x + xtile
+            if x >= xsize:
+                x, y = 0, y + ytile
+                if y >= ysize:
+                    break  # isn't really required
+
+        self.stream = stream
+        self._fp = self.fp
+        self.fp = None
+
+    def load(self) -> Image.core.PixelAccess | None:
+        if not self.fp:
+            self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"])
+
+        return ImageFile.ImageFile.load(self)
+
+    def close(self) -> None:
+        self.ole.close()
+        super().close()
+
+    def __exit__(self, *args: object) -> None:
+        self.ole.close()
+        super().__exit__()
+
+
+#
+# --------------------------------------------------------------------
+
+
+Image.register_open(FpxImageFile.format, FpxImageFile, _accept)
+
+Image.register_extension(FpxImageFile.format, ".fpx")

src/venv/Lib/site-packages/PIL/FtexImagePlugin.py

@@ -0,0 +1,115 @@
+"""
+A Pillow loader for .ftc and .ftu files (FTEX)
+Jerome Leclanche <[email protected]>
+
+The contents of this file are hereby released in the public domain (CC0)
+Full text of the CC0 license:
+  https://creativecommons.org/publicdomain/zero/1.0/
+
+Independence War 2: Edge Of Chaos - Texture File Format - 16 October 2001
+
+The textures used for 3D objects in Independence War 2: Edge Of Chaos are in a
+packed custom format called FTEX. This file format uses file extensions FTC
+and FTU.
+* FTC files are compressed textures (using standard texture compression).
+* FTU files are not compressed.
+Texture File Format
+The FTC and FTU texture files both use the same format. This
+has the following structure:
+{header}
+{format_directory}
+{data}
+Where:
+{header} = {
+    u32:magic,
+    u32:version,
+    u32:width,
+    u32:height,
+    u32:mipmap_count,
+    u32:format_count
+}
+
+* The "magic" number is "FTEX".
+* "width" and "height" are the dimensions of the texture.
+* "mipmap_count" is the number of mipmaps in the texture.
+* "format_count" is the number of texture formats (different versions of the
+same texture) in this file.
+
+{format_directory} = format_count * { u32:format, u32:where }
+
+The format value is 0 for DXT1 compressed textures and 1 for 24-bit RGB
+uncompressed textures.
+The texture data for a format starts at the position "where" in the file.
+
+Each set of texture data in the file has the following structure:
+{data} = format_count * { u32:mipmap_size, mipmap_size * { u8 } }
+* "mipmap_size" is the number of bytes in that mip level. For compressed
+textures this is the size of the texture data compressed with DXT1. For 24 bit
+uncompressed textures, this is 3 * width * height. Following this are the image
+bytes for that mipmap level.
+
+Note: All data is stored in little-Endian (Intel) byte order.
+"""
+
+from __future__ import annotations
+
+import struct
+from enum import IntEnum
+from io import BytesIO
+
+from . import Image, ImageFile
+
+MAGIC = b"FTEX"
+
+
+class Format(IntEnum):
+    DXT1 = 0
+    UNCOMPRESSED = 1
+
+
+class FtexImageFile(ImageFile.ImageFile):
+    format = "FTEX"
+    format_description = "Texture File Format (IW2:EOC)"
+
+    def _open(self) -> None:
+        if not _accept(self.fp.read(4)):
+            msg = "not an FTEX file"
+            raise SyntaxError(msg)
+        struct.unpack("<i", self.fp.read(4))  # version
+        self._size = struct.unpack("<2i", self.fp.read(8))
+        mipmap_count, format_count = struct.unpack("<2i", self.fp.read(8))
+
+        self._mode = "RGB"
+
+        # Only support single-format files.
+        # I don't know of any multi-format file.
+        assert format_count == 1
+
+        format, where = struct.unpack("<2i", self.fp.read(8))
+        self.fp.seek(where)
+        (mipmap_size,) = struct.unpack("<i", self.fp.read(4))
+
+        data = self.fp.read(mipmap_size)
+
+        if format == Format.DXT1:
+            self._mode = "RGBA"
+            self.tile = [ImageFile._Tile("bcn", (0, 0) + self.size, 0, (1,))]
+        elif format == Format.UNCOMPRESSED:
+            self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, ("RGB", 0, 1))]
+        else:
+            msg = f"Invalid texture compression format: {repr(format)}"
+            raise ValueError(msg)
+
+        self.fp.close()
+        self.fp = BytesIO(data)
+
+    def load_seek(self, pos: int) -> None:
+        pass
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix[:4] == MAGIC
+
+
+Image.register_open(FtexImageFile.format, FtexImageFile, _accept)
+Image.register_extensions(FtexImageFile.format, [".ftc", ".ftu"])