From 6a9b5282cd55567349b81594e7cb754da69dab71 Mon Sep 17 00:00:00 2001
From: Adrian Mace <5071859+adrianmace@users.noreply.github.com>
Date: Sun, 30 Nov 2025 00:39:30 +1100
Subject: [PATCH 01/26] fix: allow all IPv6 CIDRs by default

This change ensures that by default, IPv6 clients can
connect to the service unless explicitly denied.

Fixes #593
---
 dispatcharr/utils.py            | 2 +-
 frontend/src/pages/Settings.jsx | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/dispatcharr/utils.py b/dispatcharr/utils.py
index 260515fc..56243b7a 100644
--- a/dispatcharr/utils.py
+++ b/dispatcharr/utils.py
@@ -44,7 +44,7 @@ def network_access_allowed(request, settings_key):
     cidrs = (
         network_access[settings_key].split(",")
         if settings_key in network_access
-        else ["0.0.0.0/0"]
+        else ["0.0.0.0/0", "::/0"]
     )
 
     network_allowed = False
diff --git a/frontend/src/pages/Settings.jsx b/frontend/src/pages/Settings.jsx
index 10f6f5a2..5c25897a 100644
--- a/frontend/src/pages/Settings.jsx
+++ b/frontend/src/pages/Settings.jsx
@@ -278,7 +278,7 @@ const SettingsPage = () => {
   const networkAccessForm = useForm({
     mode: 'controlled',
     initialValues: Object.keys(NETWORK_ACCESS_OPTIONS).reduce((acc, key) => {
-      acc[key] = '0.0.0.0/0,::0/0';
+      acc[key] = '0.0.0.0/0,::/0';
       return acc;
     }, {}),
     validate: Object.keys(NETWORK_ACCESS_OPTIONS).reduce((acc, key) => {
@@ -358,7 +358,7 @@ const SettingsPage = () => {
       );
       networkAccessForm.setValues(
         Object.keys(NETWORK_ACCESS_OPTIONS).reduce((acc, key) => {
-          acc[key] = networkAccessSettings[key] || '0.0.0.0/0,::0/0';
+          acc[key] = networkAccessSettings[key] || '0.0.0.0/0,::/0';
           return acc;
         }, {})
       );

From 43949c3ef432d14fb9add2c7dca56aa3709959a6 Mon Sep 17 00:00:00 2001
From: 3l3m3nt <jordan@dalleyfamily.net>
Date: Sun, 30 Nov 2025 19:30:47 +1300
Subject: [PATCH 02/26] Added IPv6 port bind to nginx.conf

---
 docker/nginx.conf | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docker/nginx.conf b/docker/nginx.conf
index 5e754d20..020bc99a 100644
--- a/docker/nginx.conf
+++ b/docker/nginx.conf
@@ -3,6 +3,7 @@ proxy_cache_path /app/logo_cache levels=1:2 keys_zone=logo_cache:10m
 
 server {
     listen NGINX_PORT;
+    listen [::]:NGINX_PORT;
 
     proxy_connect_timeout 75;
     proxy_send_timeout 300;

From 641dcfc21e40cb05d42123f0276ebcc705c46608 Mon Sep 17 00:00:00 2001
From: GitHub Copilot <github-actions@github.com>
Date: Sun, 30 Nov 2025 19:20:25 +0000
Subject: [PATCH 03/26] Add sorting functionality to Group and M3U columns in
 Streams table

- Added m3u_account__name to backend ordering_fields in StreamViewSet
- Implemented field mapping in frontend to convert column IDs to backend field names
- Added sort buttons to both Group and M3U columns with proper icons
- Sort buttons show current sort state (ascending/descending/none)
- Maintains consistent UX with existing Name column sorting
---
 apps/channels/api_views.py                    |  2 +-
 .../src/components/tables/StreamsTable.jsx    | 87 ++++++++++++-------
 2 files changed, 56 insertions(+), 33 deletions(-)

diff --git a/apps/channels/api_views.py b/apps/channels/api_views.py
index bc920537..eccc5028 100644
--- a/apps/channels/api_views.py
+++ b/apps/channels/api_views.py
@@ -124,7 +124,7 @@ class StreamViewSet(viewsets.ModelViewSet):
     filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
     filterset_class = StreamFilter
     search_fields = ["name", "channel_group__name"]
-    ordering_fields = ["name", "channel_group__name"]
+    ordering_fields = ["name", "channel_group__name", "m3u_account__name"]
     ordering = ["-name"]
 
     def get_permissions(self):
diff --git a/frontend/src/components/tables/StreamsTable.jsx b/frontend/src/components/tables/StreamsTable.jsx
index d309552c..a0ae1f5e 100644
--- a/frontend/src/components/tables/StreamsTable.jsx
+++ b/frontend/src/components/tables/StreamsTable.jsx
@@ -385,7 +385,14 @@ const StreamsTable = () => {
 
     // Apply sorting
     if (sorting.length > 0) {
-      const sortField = sorting[0].id;
+      const columnId = sorting[0].id;
+      // Map frontend column IDs to backend field names
+      const fieldMapping = {
+        name: 'name',
+        group: 'channel_group__name',
+        m3u: 'm3u_account__name',
+      };
+      const sortField = fieldMapping[columnId] || columnId;
       const sortDirection = sorting[0].desc ? '-' : '';
       params.append('ordering', `${sortDirection}${sortField}`);
     }
@@ -747,41 +754,57 @@ const StreamsTable = () => {
 
       case 'group':
         return (
-          <Box onClick={handleSelectClick} style={{ width: '100%' }}>
-            <MultiSelect
-              placeholder="Group"
-              searchable
-              size="xs"
-              nothingFoundMessage="No options"
-              onClick={handleSelectClick}
-              onChange={handleGroupChange}
-              data={groupOptions}
-              variant="unstyled"
-              className="table-input-header custom-multiselect"
-              clearable
-            />
-          </Box>
+          <Flex gap="sm">
+            <Box onClick={handleSelectClick} style={{ width: '100%' }}>
+              <MultiSelect
+                placeholder="Group"
+                searchable
+                size="xs"
+                nothingFoundMessage="No options"
+                onClick={handleSelectClick}
+                onChange={handleGroupChange}
+                data={groupOptions}
+                variant="unstyled"
+                className="table-input-header custom-multiselect"
+                clearable
+              />
+            </Box>
+            <Center>
+              {React.createElement(sortingIcon, {
+                onClick: () => onSortingChange('group'),
+                size: 14,
+              })}
+            </Center>
+          </Flex>
         );
 
       case 'm3u':
         return (
-          <Box onClick={handleSelectClick}>
-            <Select
-              placeholder="M3U"
-              searchable
-              clearable
-              size="xs"
-              nothingFoundMessage="No options"
-              onClick={handleSelectClick}
-              onChange={handleM3UChange}
-              data={playlists.map((playlist) => ({
-                label: playlist.name,
-                value: `${playlist.id}`,
-              }))}
-              variant="unstyled"
-              className="table-input-header"
-            />
-          </Box>
+          <Flex gap="sm">
+            <Box onClick={handleSelectClick} style={{ width: '100%' }}>
+              <Select
+                placeholder="M3U"
+                searchable
+                clearable
+                size="xs"
+                nothingFoundMessage="No options"
+                onClick={handleSelectClick}
+                onChange={handleM3UChange}
+                data={playlists.map((playlist) => ({
+                  label: playlist.name,
+                  value: `${playlist.id}`,
+                }))}
+                variant="unstyled"
+                className="table-input-header"
+              />
+            </Box>
+            <Center>
+              {React.createElement(sortingIcon, {
+                onClick: () => onSortingChange('m3u'),
+                size: 14,
+              })}
+            </Center>
+          </Flex>
         );
     }
   };

From cf08e54bd822e38e42779e7702d774807a92571f Mon Sep 17 00:00:00 2001
From: root <root@debian-s-4vcpu-8gb-nyc3-01>
Date: Mon, 1 Dec 2025 18:11:58 +0000
Subject: [PATCH 04/26] Fix sorting functionality for Group and M3U columns

- Add missing header properties to group and m3u columns
- Fix layout issues with sort buttons (proper flex layout, remove blocking onClick)
- Fix sorting state initialization (use boolean instead of empty string)
- Fix sorting comparison operators (use strict equality)
- Fix 3rd click behavior to return to default sort instead of clearing
- Map frontend column IDs to backend field names for proper API requests
---
 .../src/components/tables/StreamsTable.jsx    | 23 +++++++++++--------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/frontend/src/components/tables/StreamsTable.jsx b/frontend/src/components/tables/StreamsTable.jsx
index a0ae1f5e..ca3ee21f 100644
--- a/frontend/src/components/tables/StreamsTable.jsx
+++ b/frontend/src/components/tables/StreamsTable.jsx
@@ -182,7 +182,7 @@ const StreamsTable = () => {
   const [pageCount, setPageCount] = useState(0);
   const [paginationString, setPaginationString] = useState('');
   const [isLoading, setIsLoading] = useState(true);
-  const [sorting, setSorting] = useState([{ id: 'name', desc: '' }]);
+  const [sorting, setSorting] = useState([{ id: 'name', desc: true }]);
   const [selectedStreamIds, setSelectedStreamIds] = useState([]);
 
   // Channel numbering modal state
@@ -298,6 +298,7 @@ const StreamsTable = () => {
         ),
       },
       {
+        header: 'Group',
         id: 'group',
         accessorFn: (row) =>
           channelGroups[row.channel_group]
@@ -319,6 +320,7 @@ const StreamsTable = () => {
         ),
       },
       {
+        header: 'M3U',
         id: 'm3u',
         size: columnSizing.m3u || 150,
         accessorFn: (row) =>
@@ -698,8 +700,8 @@ const StreamsTable = () => {
     const sortField = sorting[0]?.id;
     const sortDirection = sorting[0]?.desc;
 
-    if (sortField == column) {
-      if (sortDirection == false) {
+    if (sortField === column) {
+      if (sortDirection === false) {
         setSorting([
           {
             id: column,
@@ -707,7 +709,8 @@ const StreamsTable = () => {
           },
         ]);
       } else {
-        setSorting([]);
+        // Reset to default sort (name descending) instead of clearing
+        setSorting([{ id: 'name', desc: true }]);
       }
     } else {
       setSorting([
@@ -754,8 +757,8 @@ const StreamsTable = () => {
 
       case 'group':
         return (
-          <Flex gap="sm">
-            <Box onClick={handleSelectClick} style={{ width: '100%' }}>
+          <Flex gap="sm" style={{ width: '100%' }}>
+            <Box style={{ flex: 1, minWidth: 0 }}>
               <MultiSelect
                 placeholder="Group"
                 searchable
@@ -769,7 +772,7 @@ const StreamsTable = () => {
                 clearable
               />
             </Box>
-            <Center>
+            <Center style={{ flexShrink: 0 }}>
               {React.createElement(sortingIcon, {
                 onClick: () => onSortingChange('group'),
                 size: 14,
@@ -780,8 +783,8 @@ const StreamsTable = () => {
 
       case 'm3u':
         return (
-          <Flex gap="sm">
-            <Box onClick={handleSelectClick} style={{ width: '100%' }}>
+          <Flex gap="sm" style={{ width: '100%' }}>
+            <Box style={{ flex: 1, minWidth: 0 }}>
               <Select
                 placeholder="M3U"
                 searchable
@@ -798,7 +801,7 @@ const StreamsTable = () => {
                 className="table-input-header"
               />
             </Box>
-            <Center>
+            <Center style={{ flexShrink: 0 }}>
               {React.createElement(sortingIcon, {
                 onClick: () => onSortingChange('m3u'),
                 size: 14,

From 5e1ae23c4e21f1a93dafabab84e832fa1ad0a265 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Tue, 2 Dec 2025 14:58:22 -0600
Subject: [PATCH 05/26] docs: Update CHANGELOG

---
 CHANGELOG.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2f082eb8..8501b122 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- IPv6 access now allowed by default with all IPv6 CIDRs accepted - Thanks [@adrianmace](https://github.com/adrianmace)
+- nginx.conf updated to bind to both IPv4 and IPv6 ports - Thanks [@jordandalley](https://github.com/jordandalley)
+
 ## [0.13.0] - 2025-12-02
 
 ### Added

From f38fb36eba058a3e7bb4e0610d22a017abeb40c4 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Tue, 2 Dec 2025 15:03:34 -0600
Subject: [PATCH 06/26] Skip builds during documentation updates.

---
 .github/workflows/ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5da4118c..80bd8984 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -3,6 +3,8 @@ name: CI Pipeline
 on:
   push:
     branches: [dev]
+    paths-ignore:
+      - '**.md'
   pull_request:
     branches: [dev]
   workflow_dispatch:

From 81b657036611633a9828232a3cf3fd297c06604f Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Wed, 3 Dec 2025 17:03:58 -0600
Subject: [PATCH 07/26] Fix name not sorting.

---
 frontend/src/components/tables/StreamsTable.jsx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/frontend/src/components/tables/StreamsTable.jsx b/frontend/src/components/tables/StreamsTable.jsx
index db8b43bc..3e497f99 100644
--- a/frontend/src/components/tables/StreamsTable.jsx
+++ b/frontend/src/components/tables/StreamsTable.jsx
@@ -183,7 +183,7 @@ const StreamsTable = () => {
   const [pageCount, setPageCount] = useState(0);
   const [paginationString, setPaginationString] = useState('');
   const [isLoading, setIsLoading] = useState(true);
-  const [sorting, setSorting] = useState([{ id: 'name', desc: true }]);
+  const [sorting, setSorting] = useState([{ id: 'name', desc: false }]);
   const [selectedStreamIds, setSelectedStreamIds] = useState([]);
 
   // Channel numbering modal state
@@ -710,8 +710,8 @@ const StreamsTable = () => {
           },
         ]);
       } else {
-        // Reset to default sort (name descending) instead of clearing
-        setSorting([{ id: 'name', desc: true }]);
+        // Reset to default sort (name ascending) instead of clearing
+        setSorting([{ id: 'name', desc: false }]);
       }
     } else {
       setSorting([

From 5fce83fb5126e9a76df5bbd12c03ef60d333b2a8 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Wed, 3 Dec 2025 17:13:50 -0600
Subject: [PATCH 08/26] style: Adjust table header and input components for
 consistent width

---
 .../tables/CustomTable/CustomTableHeader.jsx  |   1 +
 .../src/components/tables/StreamsTable.jsx    | 102 ++++++++++--------
 2 files changed, 56 insertions(+), 47 deletions(-)

diff --git a/frontend/src/components/tables/CustomTable/CustomTableHeader.jsx b/frontend/src/components/tables/CustomTable/CustomTableHeader.jsx
index 92643fc9..004687dd 100644
--- a/frontend/src/components/tables/CustomTable/CustomTableHeader.jsx
+++ b/frontend/src/components/tables/CustomTable/CustomTableHeader.jsx
@@ -105,6 +105,7 @@ const CustomTableHeader = ({
                     ...(header.column.columnDef.style &&
                       header.column.columnDef.style),
                     height: '100%',
+                    width: '100%',
                     paddingRight: header.column.getCanResize() ? '8px' : '0px', // Add padding for resize handle
                   }}
                 >
diff --git a/frontend/src/components/tables/StreamsTable.jsx b/frontend/src/components/tables/StreamsTable.jsx
index 3e497f99..f3f4dc20 100644
--- a/frontend/src/components/tables/StreamsTable.jsx
+++ b/frontend/src/components/tables/StreamsTable.jsx
@@ -736,7 +736,7 @@ const StreamsTable = () => {
     switch (header.id) {
       case 'name':
         return (
-          <Flex gap="sm">
+          <Flex align="center" style={{ width: '100%', flex: 1 }}>
             <TextInput
               name="name"
               placeholder="Name"
@@ -747,68 +747,76 @@ const StreamsTable = () => {
               variant="unstyled"
               className="table-input-header"
               leftSection={<Search size={14} opacity={0.5} />}
-            />
-            <Center>
-              {React.createElement(sortingIcon, {
-                onClick: () => onSortingChange('name'),
+              style={{ flex: 1, minWidth: 0 }}
+              rightSectionPointerEvents="auto"
+              rightSection={React.createElement(sortingIcon, {
+                onClick: (e) => {
+                  e.stopPropagation();
+                  onSortingChange('name');
+                },
                 size: 14,
+                style: { cursor: 'pointer' },
               })}
-            </Center>
+            />
           </Flex>
         );
 
       case 'group':
         return (
-          <Flex gap="sm" style={{ width: '100%' }}>
-            <Box style={{ flex: 1, minWidth: 0 }}>
-              <MultiSelect
-                placeholder="Group"
-                searchable
-                size="xs"
-                nothingFoundMessage="No options"
-                onClick={handleSelectClick}
-                onChange={handleGroupChange}
-                data={groupOptions}
-                variant="unstyled"
-                className="table-input-header custom-multiselect"
-                clearable
-              />
-            </Box>
-            <Center style={{ flexShrink: 0 }}>
-              {React.createElement(sortingIcon, {
-                onClick: () => onSortingChange('group'),
+          <Flex align="center" style={{ width: '100%', flex: 1 }}>
+            <MultiSelect
+              placeholder="Group"
+              searchable
+              size="xs"
+              nothingFoundMessage="No options"
+              onClick={handleSelectClick}
+              onChange={handleGroupChange}
+              data={groupOptions}
+              variant="unstyled"
+              className="table-input-header custom-multiselect"
+              clearable
+              style={{ flex: 1, minWidth: 0 }}
+              rightSectionPointerEvents="auto"
+              rightSection={React.createElement(sortingIcon, {
+                onClick: (e) => {
+                  e.stopPropagation();
+                  onSortingChange('group');
+                },
                 size: 14,
+                style: { cursor: 'pointer' },
               })}
-            </Center>
+            />
           </Flex>
         );
 
       case 'm3u':
         return (
-          <Flex gap="sm" style={{ width: '100%' }}>
-            <Box style={{ flex: 1, minWidth: 0 }}>
-              <Select
-                placeholder="M3U"
-                searchable
-                clearable
-                size="xs"
-                nothingFoundMessage="No options"
-                onClick={handleSelectClick}
-                onChange={handleM3UChange}
-                data={playlists.map((playlist) => ({
-                  label: playlist.name,
-                  value: `${playlist.id}`,
-                }))}
-                variant="unstyled"
-                className="table-input-header"
-              />
-            </Box>
-            <Center style={{ flexShrink: 0 }}>
-              {React.createElement(sortingIcon, {
-                onClick: () => onSortingChange('m3u'),
+          <Flex align="center" style={{ width: '100%', flex: 1 }}>
+            <Select
+              placeholder="M3U"
+              searchable
+              clearable
+              size="xs"
+              nothingFoundMessage="No options"
+              onClick={handleSelectClick}
+              onChange={handleM3UChange}
+              data={playlists.map((playlist) => ({
+                label: playlist.name,
+                value: `${playlist.id}`,
+              }))}
+              variant="unstyled"
+              className="table-input-header"
+              style={{ flex: 1, minWidth: 0 }}
+              rightSectionPointerEvents="auto"
+              rightSection={React.createElement(sortingIcon, {
+                onClick: (e) => {
+                  e.stopPropagation();
+                  onSortingChange('m3u');
+                },
                 size: 14,
+                style: { cursor: 'pointer' },
               })}
-            </Center>
+            />
           </Flex>
         );
     }

From 2de6ac5da1802566f220a7abb359943b8a2c61f3 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Wed, 3 Dec 2025 17:31:16 -0600
Subject: [PATCH 09/26] changelog: Add sort buttons for 'Group' and 'M3U'
 columns in Streams table

---
 CHANGELOG.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8501b122..501c0aea 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Sort buttons for 'Group' and 'M3U' columns in Streams table for improved stream organization and filtering - Thanks [@bobey6](https://github.com/bobey6)
+
 ### Changed
 
 - IPv6 access now allowed by default with all IPv6 CIDRs accepted - Thanks [@adrianmace](https://github.com/adrianmace)

From 2a8ba9125c053de988bb5a7a446118f83e3c5223 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Thu, 4 Dec 2025 14:07:28 -0600
Subject: [PATCH 10/26] perf: optimize EPG program parsing for multi-channel
 sources

Dramatically improve EPG refresh performance by parsing the XML file once
per source instead of once per channel. The new implementation:

- Pre-filters to only process EPG entries mapped to actual channels
- Parses the entire XML file in a single pass
- Uses O(1) set lookups to skip unmapped channel programmes
- Skips non-mapped channels entirely with minimal overhead

For EPG sources with many channels but few mapped (e.g., 10,000 channels
with 100 mapped to channels), this provides approximately:
- 99% reduction in file open operations
- 99% reduction in XML file scans
- Proportional reduction in CPU and I/O overhead

The parse_programs_for_tvg_id() function is retained for single-channel
use cases (e.g., when a new channel is mapped via signals).

Fixes inefficient repeated file parsing that was occurring with large
EPG sources.
---
 CHANGELOG.md      |   1 +
 apps/epg/tasks.py | 279 ++++++++++++++++++++++++++++++++++------------
 2 files changed, 209 insertions(+), 71 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 501c0aea..65100539 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- **Performance**: EPG program parsing optimized for sources with many channels but only a fraction mapped. Now parses XML file once per source instead of once per channel, dramatically reducing I/O and CPU overhead. For sources with 10,000 channels and 100 mapped, this results in ~99x fewer file opens and ~100x fewer full file scans.
 - IPv6 access now allowed by default with all IPv6 CIDRs accepted - Thanks [@adrianmace](https://github.com/adrianmace)
 - nginx.conf updated to bind to both IPv4 and IPv6 ports - Thanks [@jordandalley](https://github.com/jordandalley)
 
diff --git a/apps/epg/tasks.py b/apps/epg/tasks.py
index 59d658b1..3ed222d9 100644
--- a/apps/epg/tasks.py
+++ b/apps/epg/tasks.py
@@ -1393,11 +1393,23 @@ def parse_programs_for_tvg_id(epg_id):
 
 
 def parse_programs_for_source(epg_source, tvg_id=None):
+    """
+    Parse programs for all MAPPED channels from an EPG source in a single pass.
+
+    This is an optimized version that:
+    1. Only processes EPG entries that are actually mapped to channels
+    2. Parses the XML file ONCE instead of once per channel
+    3. Skips programmes for unmapped channels entirely during parsing
+
+    This dramatically improves performance when an EPG source has many channels
+    but only a fraction are mapped.
+    """
     # Send initial programs parsing notification
     send_epg_update(epg_source.id, "parsing_programs", 0)
     should_log_memory = False
     process = None
     initial_memory = 0
+    source_file = None
 
     # Add memory tracking only in trace mode or higher
     try:
@@ -1417,82 +1429,199 @@ def parse_programs_for_source(epg_source, tvg_id=None):
         should_log_memory = False
 
     try:
-        # Process EPG entries in batches rather than all at once
-        batch_size = 20  # Process fewer channels at once to reduce memory usage
-        epg_count = EPGData.objects.filter(epg_source=epg_source).count()
+        # Only get EPG entries that are actually mapped to channels
+        mapped_epg_ids = set(
+            Channel.objects.filter(
+                epg_data__epg_source=epg_source,
+                epg_data__isnull=False
+            ).values_list('epg_data_id', flat=True)
+        )
 
-        if epg_count == 0:
-            logger.info(f"No EPG entries found for source: {epg_source.name}")
-            # Update status - this is not an error, just no entries
+        if not mapped_epg_ids:
+            total_epg_count = EPGData.objects.filter(epg_source=epg_source).count()
+            logger.info(f"No channels mapped to any EPG entries from source: {epg_source.name} "
+                       f"(source has {total_epg_count} EPG entries, 0 mapped)")
+            # Update status - this is not an error, just no mapped entries
             epg_source.status = 'success'
-            epg_source.save(update_fields=['status'])
+            epg_source.last_message = f"No channels mapped to this EPG source ({total_epg_count} entries available)"
+            epg_source.save(update_fields=['status', 'last_message'])
             send_epg_update(epg_source.id, "parsing_programs", 100, status="success")
             return True
 
-        logger.info(f"Parsing programs for {epg_count} EPG entries from source: {epg_source.name}")
+        # Get the mapped EPG entries with their tvg_ids
+        mapped_epgs = EPGData.objects.filter(id__in=mapped_epg_ids).values('id', 'tvg_id')
+        tvg_id_to_epg_id = {epg['tvg_id']: epg['id'] for epg in mapped_epgs if epg['tvg_id']}
+        mapped_tvg_ids = set(tvg_id_to_epg_id.keys())
 
-        failed_entries = []
-        program_count = 0
-        channel_count = 0
-        updated_count = 0
-        processed = 0
-        # Process in batches using cursor-based approach to limit memory usage
-        last_id = 0
-        while True:
-            # Get a batch of EPG entries
-            batch_entries = list(EPGData.objects.filter(
-                epg_source=epg_source,
-                id__gt=last_id
-            ).order_by('id')[:batch_size])
+        total_epg_count = EPGData.objects.filter(epg_source=epg_source).count()
+        mapped_count = len(mapped_tvg_ids)
 
-            if not batch_entries:
-                break  # No more entries to process
+        logger.info(f"Parsing programs for {mapped_count} MAPPED channels from source: {epg_source.name} "
+                   f"(skipping {total_epg_count - mapped_count} unmapped EPG entries)")
 
-            # Update last_id for next iteration
-            last_id = batch_entries[-1].id
+        # Get the file path
+        file_path = epg_source.extracted_file_path if epg_source.extracted_file_path else epg_source.file_path
+        if not file_path:
+            file_path = epg_source.get_cache_file()
 
-            # Process this batch
-            for epg in batch_entries:
-                if epg.tvg_id:
-                    try:
-                        result = parse_programs_for_tvg_id(epg.id)
-                        if result == "Task already running":
-                            logger.info(f"Program parse for {epg.id} already in progress, skipping")
+        # Check if the file exists
+        if not os.path.exists(file_path):
+            logger.error(f"EPG file not found at: {file_path}")
 
-                        processed += 1
-                        progress = min(95, int((processed / epg_count) * 100)) if epg_count > 0 else 50
-                        send_epg_update(epg_source.id, "parsing_programs", progress)
-                    except Exception as e:
-                        logger.error(f"Error parsing programs for tvg_id={epg.tvg_id}: {e}", exc_info=True)
-                        failed_entries.append(f"{epg.tvg_id}: {str(e)}")
+            if epg_source.url:
+                # Update the file path in the database
+                new_path = epg_source.get_cache_file()
+                logger.info(f"Updating file_path from '{file_path}' to '{new_path}'")
+                epg_source.file_path = new_path
+                epg_source.save(update_fields=['file_path'])
+                logger.info(f"Fetching new EPG data from URL: {epg_source.url}")
 
-            # Force garbage collection after each batch
-            batch_entries = None  # Remove reference to help garbage collection
+                # Fetch new data before continuing
+                fetch_success = fetch_xmltv(epg_source)
+
+                if not fetch_success:
+                    logger.error(f"Failed to fetch EPG data for source: {epg_source.name}")
+                    epg_source.status = 'error'
+                    epg_source.last_message = f"Failed to download EPG data"
+                    epg_source.save(update_fields=['status', 'last_message'])
+                    send_epg_update(epg_source.id, "parsing_programs", 100, status="error", error="Failed to download EPG file")
+                    return False
+
+                # Update file_path with the new location
+                file_path = epg_source.extracted_file_path if epg_source.extracted_file_path else epg_source.file_path
+            else:
+                logger.error(f"No URL provided for EPG source {epg_source.name}, cannot fetch new data")
+                epg_source.status = 'error'
+                epg_source.last_message = f"No URL provided, cannot fetch EPG data"
+                epg_source.save(update_fields=['status', 'last_message'])
+                send_epg_update(epg_source.id, "parsing_programs", 100, status="error", error="No URL provided")
+                return False
+
+        # Delete existing programs for all mapped EPGs in one query
+        logger.info(f"Deleting existing programs for {mapped_count} mapped EPG entries...")
+        deleted_count = ProgramData.objects.filter(epg_id__in=mapped_epg_ids).delete()[0]
+        logger.info(f"Deleted {deleted_count} existing programs")
+
+        # SINGLE PASS PARSING: Parse the XML file once and process all mapped channels
+        programs_to_create = []
+        programs_by_channel = {tvg_id: 0 for tvg_id in mapped_tvg_ids}  # Track count per channel
+        total_programs = 0
+        skipped_programs = 0
+        batch_size = 1000
+        last_progress_update = 0
+
+        try:
+            logger.debug(f"Opening file for single-pass parsing: {file_path}")
+            source_file = open(file_path, 'rb')
+
+            # Stream parse the file using lxml's iterparse
+            program_parser = etree.iterparse(source_file, events=('end',), tag='programme', remove_blank_text=True, recover=True)
+
+            for _, elem in program_parser:
+                channel_id = elem.get('channel')
+
+                # Skip programmes for unmapped channels immediately
+                if channel_id not in mapped_tvg_ids:
+                    skipped_programs += 1
+                    # Clear element to free memory
+                    clear_element(elem)
+                    continue
+
+                # This programme is for a mapped channel - process it
+                try:
+                    start_time = parse_xmltv_time(elem.get('start'))
+                    end_time = parse_xmltv_time(elem.get('stop'))
+                    title = None
+                    desc = None
+                    sub_title = None
+
+                    # Efficiently process child elements
+                    for child in elem:
+                        if child.tag == 'title':
+                            title = child.text or 'No Title'
+                        elif child.tag == 'desc':
+                            desc = child.text or ''
+                        elif child.tag == 'sub-title':
+                            sub_title = child.text or ''
+
+                    if not title:
+                        title = 'No Title'
+
+                    # Extract custom properties
+                    custom_props = extract_custom_properties(elem)
+                    custom_properties_json = custom_props if custom_props else None
+
+                    epg_id = tvg_id_to_epg_id[channel_id]
+                    programs_to_create.append(ProgramData(
+                        epg_id=epg_id,
+                        start_time=start_time,
+                        end_time=end_time,
+                        title=title,
+                        description=desc,
+                        sub_title=sub_title,
+                        tvg_id=channel_id,
+                        custom_properties=custom_properties_json
+                    ))
+                    total_programs += 1
+                    programs_by_channel[channel_id] += 1
+
+                    # Clear the element to free memory
+                    clear_element(elem)
+
+                    # Batch processing
+                    if len(programs_to_create) >= batch_size:
+                        ProgramData.objects.bulk_create(programs_to_create)
+                        logger.debug(f"Saved batch of {len(programs_to_create)} programs (total: {total_programs})")
+                        programs_to_create = []
+
+                        # Send progress update (estimate based on programs processed)
+                        # We don't know total programs upfront, so use a rough estimate
+                        if total_programs - last_progress_update >= 5000:
+                            last_progress_update = total_programs
+                            # Cap at 90% until we're done
+                            progress = min(90, 10 + int((total_programs / max(total_programs + 10000, 1)) * 80))
+                            send_epg_update(epg_source.id, "parsing_programs", progress,
+                                          processed=total_programs, channels=mapped_count)
+
+                        # Periodic garbage collection
+                        if total_programs % (batch_size * 5) == 0:
+                            gc.collect()
+
+                except Exception as e:
+                    logger.error(f"Error processing program for {channel_id}: {e}", exc_info=True)
+                    clear_element(elem)
+                    continue
+
+            # Process any remaining items
+            if programs_to_create:
+                ProgramData.objects.bulk_create(programs_to_create)
+                logger.debug(f"Saved final batch of {len(programs_to_create)} programs")
+
+        except etree.XMLSyntaxError as xml_error:
+            logger.error(f"XML syntax error parsing program data: {xml_error}")
+            epg_source.status = EPGSource.STATUS_ERROR
+            epg_source.last_message = f"XML parsing error: {str(xml_error)}"
+            epg_source.save(update_fields=['status', 'last_message'])
+            send_epg_update(epg_source.id, "parsing_programs", 100, status="error", message=str(xml_error))
+            return False
+        except Exception as e:
+            logger.error(f"Error parsing XML for programs: {e}", exc_info=True)
+            raise
+        finally:
+            if source_file:
+                source_file.close()
+                source_file = None
             gc.collect()
 
-        # If there were failures, include them in the message but continue
-        if failed_entries:
-            epg_source.status = EPGSource.STATUS_SUCCESS  # Still mark as success if some processed
-            error_summary = f"Failed to parse {len(failed_entries)} of {epg_count} entries"
-            stats_summary = f"Processed {program_count} programs across {channel_count} channels. Updated: {updated_count}."
-            epg_source.last_message = f"{stats_summary} Warning: {error_summary}"
-            epg_source.updated_at = timezone.now()
-            epg_source.save(update_fields=['status', 'last_message', 'updated_at'])
+        # Count channels that actually got programs
+        channels_with_programs = sum(1 for count in programs_by_channel.values() if count > 0)
 
-            # Send completion notification with mixed status
-            send_epg_update(epg_source.id, "parsing_programs", 100,
-                          status="success",
-                          message=epg_source.last_message)
-
-            # Explicitly release memory of large lists before returning
-            del failed_entries
-            gc.collect()
-
-            return True
-
-        # If all successful, set a comprehensive success message
+        # Success message
         epg_source.status = EPGSource.STATUS_SUCCESS
-        epg_source.last_message = f"Successfully processed {program_count} programs across {channel_count} channels. Updated: {updated_count}."
+        epg_source.last_message = (
+            f"Parsed {total_programs:,} programs for {channels_with_programs} channels "
+            f"(skipped {skipped_programs:,} programmes for {total_epg_count - mapped_count} unmapped channels)"
+        )
         epg_source.updated_at = timezone.now()
         epg_source.save(update_fields=['status', 'last_message', 'updated_at'])
 
@@ -1500,9 +1629,10 @@ def parse_programs_for_source(epg_source, tvg_id=None):
         log_system_event(
             event_type='epg_refresh',
             source_name=epg_source.name,
-            programs=program_count,
-            channels=channel_count,
-            updated=updated_count,
+            programs=total_programs,
+            channels=channels_with_programs,
+            skipped_programs=skipped_programs,
+            unmapped_channels=total_epg_count - mapped_count,
         )
 
         # Send completion notification with status
@@ -1510,7 +1640,9 @@ def parse_programs_for_source(epg_source, tvg_id=None):
                       status="success",
                       message=epg_source.last_message)
 
-        logger.info(f"Completed parsing all programs for source: {epg_source.name}")
+        logger.info(f"Completed parsing programs for source: {epg_source.name} - "
+                   f"{total_programs:,} programs for {channels_with_programs} channels, "
+                   f"skipped {skipped_programs:,} programmes for unmapped channels")
         return True
 
     except Exception as e:
@@ -1525,14 +1657,19 @@ def parse_programs_for_source(epg_source, tvg_id=None):
         return False
     finally:
         # Final memory cleanup and tracking
-
+        if source_file:
+            try:
+                source_file.close()
+            except:
+                pass
+            source_file = None
 
         # Explicitly release any remaining large data structures
-        failed_entries = None
-        program_count = None
-        channel_count = None
-        updated_count = None
-        processed = None
+        programs_to_create = None
+        programs_by_channel = None
+        mapped_epg_ids = None
+        mapped_tvg_ids = None
+        tvg_id_to_epg_id = None
         gc.collect()
 
         # Add comprehensive memory cleanup at the end

From 256ac2f55ab64a6f56f041957f1ae73f8ef6357f Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Thu, 4 Dec 2025 14:25:44 -0600
Subject: [PATCH 11/26] Enhancement: Clean up orphaned programs for unmapped
 EPG entries

---
 CHANGELOG.md      |  2 +-
 apps/epg/tasks.py | 11 +++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 65100539..9bc21c7c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,7 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- **Performance**: EPG program parsing optimized for sources with many channels but only a fraction mapped. Now parses XML file once per source instead of once per channel, dramatically reducing I/O and CPU overhead. For sources with 10,000 channels and 100 mapped, this results in ~99x fewer file opens and ~100x fewer full file scans.
+- **Performance**: EPG program parsing optimized for sources with many channels but only a fraction mapped. Now parses XML file once per source instead of once per channel, dramatically reducing I/O and CPU overhead. For sources with 10,000 channels and 100 mapped, this results in ~99x fewer file opens and ~100x fewer full file scans. Orphaned programs for unmapped channels are also cleaned up during refresh to prevent database bloat.
 - IPv6 access now allowed by default with all IPv6 CIDRs accepted - Thanks [@adrianmace](https://github.com/adrianmace)
 - nginx.conf updated to bind to both IPv4 and IPv6 ports - Thanks [@jordandalley](https://github.com/jordandalley)
 
diff --git a/apps/epg/tasks.py b/apps/epg/tasks.py
index 3ed222d9..4a4adddd 100644
--- a/apps/epg/tasks.py
+++ b/apps/epg/tasks.py
@@ -1502,6 +1502,17 @@ def parse_programs_for_source(epg_source, tvg_id=None):
         deleted_count = ProgramData.objects.filter(epg_id__in=mapped_epg_ids).delete()[0]
         logger.info(f"Deleted {deleted_count} existing programs")
 
+        # Clean up orphaned programs for unmapped EPG entries
+        # These accumulate if a channel is unmapped after being mapped
+        unmapped_epg_ids = EPGData.objects.filter(
+            epg_source=epg_source
+        ).exclude(id__in=mapped_epg_ids).values_list('id', flat=True)
+
+        if unmapped_epg_ids:
+            orphaned_count = ProgramData.objects.filter(epg_id__in=unmapped_epg_ids).delete()[0]
+            if orphaned_count > 0:
+                logger.info(f"Cleaned up {orphaned_count} orphaned programs for {len(unmapped_epg_ids)} unmapped EPG entries")
+
         # SINGLE PASS PARSING: Parse the XML file once and process all mapped channels
         programs_to_create = []
         programs_by_channel = {tvg_id: 0 for tvg_id in mapped_tvg_ids}  # Track count per channel

From 5693ee7f9e3431d1b1fe86df48bc5e9951439a2a Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Thu, 4 Dec 2025 14:57:57 -0600
Subject: [PATCH 12/26] perf: optimize EPG program parsing and implement atomic
 database updates to reduce I/O overhead and prevent partial data visibility

---
 CHANGELOG.md      |   2 +-
 apps/epg/tasks.py | 103 +++++++++++++++++++++++++++-------------------
 2 files changed, 62 insertions(+), 43 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9bc21c7c..e46bffe1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,7 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- **Performance**: EPG program parsing optimized for sources with many channels but only a fraction mapped. Now parses XML file once per source instead of once per channel, dramatically reducing I/O and CPU overhead. For sources with 10,000 channels and 100 mapped, this results in ~99x fewer file opens and ~100x fewer full file scans. Orphaned programs for unmapped channels are also cleaned up during refresh to prevent database bloat.
+- **Performance**: EPG program parsing optimized for sources with many channels but only a fraction mapped. Now parses XML file once per source instead of once per channel, dramatically reducing I/O and CPU overhead. For sources with 10,000 channels and 100 mapped, this results in ~99x fewer file opens and ~100x fewer full file scans. Orphaned programs for unmapped channels are also cleaned up during refresh to prevent database bloat. Database updates are now atomic to prevent clients from seeing empty/partial EPG data during refresh.
 - IPv6 access now allowed by default with all IPv6 CIDRs accepted - Thanks [@adrianmace](https://github.com/adrianmace)
 - nginx.conf updated to bind to both IPv4 and IPv6 ports - Thanks [@jordandalley](https://github.com/jordandalley)
 
diff --git a/apps/epg/tasks.py b/apps/epg/tasks.py
index 4a4adddd..9fa999cd 100644
--- a/apps/epg/tasks.py
+++ b/apps/epg/tasks.py
@@ -1497,28 +1497,13 @@ def parse_programs_for_source(epg_source, tvg_id=None):
                 send_epg_update(epg_source.id, "parsing_programs", 100, status="error", error="No URL provided")
                 return False
 
-        # Delete existing programs for all mapped EPGs in one query
-        logger.info(f"Deleting existing programs for {mapped_count} mapped EPG entries...")
-        deleted_count = ProgramData.objects.filter(epg_id__in=mapped_epg_ids).delete()[0]
-        logger.info(f"Deleted {deleted_count} existing programs")
-
-        # Clean up orphaned programs for unmapped EPG entries
-        # These accumulate if a channel is unmapped after being mapped
-        unmapped_epg_ids = EPGData.objects.filter(
-            epg_source=epg_source
-        ).exclude(id__in=mapped_epg_ids).values_list('id', flat=True)
-
-        if unmapped_epg_ids:
-            orphaned_count = ProgramData.objects.filter(epg_id__in=unmapped_epg_ids).delete()[0]
-            if orphaned_count > 0:
-                logger.info(f"Cleaned up {orphaned_count} orphaned programs for {len(unmapped_epg_ids)} unmapped EPG entries")
-
-        # SINGLE PASS PARSING: Parse the XML file once and process all mapped channels
-        programs_to_create = []
+        # SINGLE PASS PARSING: Parse the XML file once and collect all programs in memory
+        # We parse FIRST, then do an atomic delete+insert to avoid race conditions
+        # where clients might see empty/partial EPG data during the transition
+        all_programs_to_create = []
         programs_by_channel = {tvg_id: 0 for tvg_id in mapped_tvg_ids}  # Track count per channel
         total_programs = 0
         skipped_programs = 0
-        batch_size = 1000
         last_progress_update = 0
 
         try:
@@ -1563,7 +1548,7 @@ def parse_programs_for_source(epg_source, tvg_id=None):
                     custom_properties_json = custom_props if custom_props else None
 
                     epg_id = tvg_id_to_epg_id[channel_id]
-                    programs_to_create.append(ProgramData(
+                    all_programs_to_create.append(ProgramData(
                         epg_id=epg_id,
                         start_time=start_time,
                         end_time=end_time,
@@ -1579,35 +1564,23 @@ def parse_programs_for_source(epg_source, tvg_id=None):
                     # Clear the element to free memory
                     clear_element(elem)
 
-                    # Batch processing
-                    if len(programs_to_create) >= batch_size:
-                        ProgramData.objects.bulk_create(programs_to_create)
-                        logger.debug(f"Saved batch of {len(programs_to_create)} programs (total: {total_programs})")
-                        programs_to_create = []
+                    # Send progress update (estimate based on programs processed)
+                    if total_programs - last_progress_update >= 5000:
+                        last_progress_update = total_programs
+                        # Cap at 70% during parsing phase (save 30% for DB operations)
+                        progress = min(70, 10 + int((total_programs / max(total_programs + 10000, 1)) * 60))
+                        send_epg_update(epg_source.id, "parsing_programs", progress,
+                                      processed=total_programs, channels=mapped_count)
 
-                        # Send progress update (estimate based on programs processed)
-                        # We don't know total programs upfront, so use a rough estimate
-                        if total_programs - last_progress_update >= 5000:
-                            last_progress_update = total_programs
-                            # Cap at 90% until we're done
-                            progress = min(90, 10 + int((total_programs / max(total_programs + 10000, 1)) * 80))
-                            send_epg_update(epg_source.id, "parsing_programs", progress,
-                                          processed=total_programs, channels=mapped_count)
-
-                        # Periodic garbage collection
-                        if total_programs % (batch_size * 5) == 0:
-                            gc.collect()
+                    # Periodic garbage collection during parsing
+                    if total_programs % 5000 == 0:
+                        gc.collect()
 
                 except Exception as e:
                     logger.error(f"Error processing program for {channel_id}: {e}", exc_info=True)
                     clear_element(elem)
                     continue
 
-            # Process any remaining items
-            if programs_to_create:
-                ProgramData.objects.bulk_create(programs_to_create)
-                logger.debug(f"Saved final batch of {len(programs_to_create)} programs")
-
         except etree.XMLSyntaxError as xml_error:
             logger.error(f"XML syntax error parsing program data: {xml_error}")
             epg_source.status = EPGSource.STATUS_ERROR
@@ -1622,6 +1595,52 @@ def parse_programs_for_source(epg_source, tvg_id=None):
             if source_file:
                 source_file.close()
                 source_file = None
+
+        # Now perform atomic delete + bulk insert
+        # This ensures clients never see empty/partial EPG data
+        logger.info(f"Parsed {total_programs} programs, performing atomic database update...")
+        send_epg_update(epg_source.id, "parsing_programs", 75, message="Updating database...")
+
+        batch_size = 1000
+        try:
+            with transaction.atomic():
+                # Delete existing programs for mapped EPGs
+                deleted_count = ProgramData.objects.filter(epg_id__in=mapped_epg_ids).delete()[0]
+                logger.debug(f"Deleted {deleted_count} existing programs")
+
+                # Clean up orphaned programs for unmapped EPG entries
+                unmapped_epg_ids = list(EPGData.objects.filter(
+                    epg_source=epg_source
+                ).exclude(id__in=mapped_epg_ids).values_list('id', flat=True))
+
+                if unmapped_epg_ids:
+                    orphaned_count = ProgramData.objects.filter(epg_id__in=unmapped_epg_ids).delete()[0]
+                    if orphaned_count > 0:
+                        logger.info(f"Cleaned up {orphaned_count} orphaned programs for {len(unmapped_epg_ids)} unmapped EPG entries")
+
+                # Bulk insert all new programs in batches within the same transaction
+                for i in range(0, len(all_programs_to_create), batch_size):
+                    batch = all_programs_to_create[i:i + batch_size]
+                    ProgramData.objects.bulk_create(batch)
+
+                    # Update progress during insertion
+                    progress = 75 + int((i / len(all_programs_to_create)) * 20) if all_programs_to_create else 95
+                    if i % (batch_size * 5) == 0:
+                        send_epg_update(epg_source.id, "parsing_programs", min(95, progress),
+                                      message=f"Inserting programs... {i}/{len(all_programs_to_create)}")
+
+            logger.info(f"Atomic update complete: deleted {deleted_count}, inserted {total_programs} programs")
+
+        except Exception as db_error:
+            logger.error(f"Database error during atomic update: {db_error}", exc_info=True)
+            epg_source.status = EPGSource.STATUS_ERROR
+            epg_source.last_message = f"Database error: {str(db_error)}"
+            epg_source.save(update_fields=['status', 'last_message'])
+            send_epg_update(epg_source.id, "parsing_programs", 100, status="error", message=str(db_error))
+            return False
+        finally:
+            # Clear the large list to free memory
+            all_programs_to_create = None
             gc.collect()
 
         # Count channels that actually got programs

From 6c8270d0e582ea7667db75036b354de72e972673 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Thu, 4 Dec 2025 15:28:21 -0600
Subject: [PATCH 13/26] Enhancement: Add support for 'extracting' status and
 display additional progress information in EPGsTable

---
 CHANGELOG.md                                 |  1 +
 frontend/src/components/tables/EPGsTable.jsx | 63 +++++++++++++++++---
 2 files changed, 56 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e46bffe1..0de26314 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - **Performance**: EPG program parsing optimized for sources with many channels but only a fraction mapped. Now parses XML file once per source instead of once per channel, dramatically reducing I/O and CPU overhead. For sources with 10,000 channels and 100 mapped, this results in ~99x fewer file opens and ~100x fewer full file scans. Orphaned programs for unmapped channels are also cleaned up during refresh to prevent database bloat. Database updates are now atomic to prevent clients from seeing empty/partial EPG data during refresh.
+- EPG table now displays detailed status messages including refresh progress, success messages, and last message for idle sources (matching M3U table behavior)
 - IPv6 access now allowed by default with all IPv6 CIDRs accepted - Thanks [@adrianmace](https://github.com/adrianmace)
 - nginx.conf updated to bind to both IPv4 and IPv6 ports - Thanks [@jordandalley](https://github.com/jordandalley)
 
diff --git a/frontend/src/components/tables/EPGsTable.jsx b/frontend/src/components/tables/EPGsTable.jsx
index 71e920e0..b8dfeb6d 100644
--- a/frontend/src/components/tables/EPGsTable.jsx
+++ b/frontend/src/components/tables/EPGsTable.jsx
@@ -160,6 +160,9 @@ const EPGsTable = () => {
       case 'downloading':
         label = 'Downloading';
         break;
+      case 'extracting':
+        label = 'Extracting';
+        break;
       case 'parsing_channels':
         label = 'Parsing Channels';
         break;
@@ -170,6 +173,22 @@ const EPGsTable = () => {
         return null;
     }
 
+    // Build additional info string from progress data
+    let additionalInfo = '';
+    if (progress.message) {
+      additionalInfo = progress.message;
+    } else if (
+      progress.processed !== undefined &&
+      progress.channels !== undefined
+    ) {
+      additionalInfo = `${progress.processed.toLocaleString()} programs for ${progress.channels} channels`;
+    } else if (
+      progress.processed !== undefined &&
+      progress.total !== undefined
+    ) {
+      additionalInfo = `${progress.processed.toLocaleString()} / ${progress.total.toLocaleString()}`;
+    }
+
     return (
       <Stack spacing={2}>
         <Text size="xs">
@@ -181,7 +200,14 @@ const EPGsTable = () => {
           style={{ margin: '2px 0' }}
         />
         {progress.speed && (
-          <Text size="xs">Speed: {parseInt(progress.speed)} KB/s</Text>
+          <Text size="xs" c="dimmed">
+            Speed: {parseInt(progress.speed)} KB/s
+          </Text>
+        )}
+        {additionalInfo && (
+          <Text size="xs" c="dimmed" lineClamp={1}>
+            {additionalInfo}
+          </Text>
         )}
       </Stack>
     );
@@ -286,14 +312,35 @@ const EPGsTable = () => {
 
           // Show success message for successful sources
           if (data.status === 'success') {
+            const successMessage =
+              data.last_message || 'EPG data refreshed successfully';
             return (
-              <Text
-                c="dimmed"
-                size="xs"
-                style={{ color: theme.colors.green[6], lineHeight: 1.3 }}
-              >
-                EPG data refreshed successfully
-              </Text>
+              <Tooltip label={successMessage} multiline width={300}>
+                <Text
+                  c="dimmed"
+                  size="xs"
+                  lineClamp={2}
+                  style={{ color: theme.colors.green[6], lineHeight: 1.3 }}
+                >
+                  {successMessage}
+                </Text>
+              </Tooltip>
+            );
+          }
+
+          // Show last_message for idle sources (from previous refresh)
+          if (data.status === 'idle' && data.last_message) {
+            return (
+              <Tooltip label={data.last_message} multiline width={300}>
+                <Text
+                  c="dimmed"
+                  size="xs"
+                  lineClamp={2}
+                  style={{ lineHeight: 1.3 }}
+                >
+                  {data.last_message}
+                </Text>
+              </Tooltip>
             );
           }
 

From 3b34fb11ef0d401c07be61ec8f0c76228fdf3485 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Thu, 4 Dec 2025 15:43:33 -0600
Subject: [PATCH 14/26] Fix: Fixes bug where Updated column wouldn't update in
 the EPG table without a webui refresh.

---
 CHANGELOG.md               |  3 ++-
 apps/epg/tasks.py          |  3 ++-
 frontend/src/WebSocket.jsx | 10 ++++++++--
 3 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0de26314..8a77b7b7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,7 +14,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - **Performance**: EPG program parsing optimized for sources with many channels but only a fraction mapped. Now parses XML file once per source instead of once per channel, dramatically reducing I/O and CPU overhead. For sources with 10,000 channels and 100 mapped, this results in ~99x fewer file opens and ~100x fewer full file scans. Orphaned programs for unmapped channels are also cleaned up during refresh to prevent database bloat. Database updates are now atomic to prevent clients from seeing empty/partial EPG data during refresh.
-- EPG table now displays detailed status messages including refresh progress, success messages, and last message for idle sources (matching M3U table behavior)
+- EPG table now displays detailed status messages including refresh progress, success messages, and last message for idle sources (matching M3U table behavior) (Closes #214)
+- EPG table "Updated" column now updates in real-time via WebSocket using the actual backend timestamp instead of requiring a page refresh
 - IPv6 access now allowed by default with all IPv6 CIDRs accepted - Thanks [@adrianmace](https://github.com/adrianmace)
 - nginx.conf updated to bind to both IPv4 and IPv6 ports - Thanks [@jordandalley](https://github.com/jordandalley)
 
diff --git a/apps/epg/tasks.py b/apps/epg/tasks.py
index 9fa999cd..c565dbf5 100644
--- a/apps/epg/tasks.py
+++ b/apps/epg/tasks.py
@@ -1668,7 +1668,8 @@ def parse_programs_for_source(epg_source, tvg_id=None):
         # Send completion notification with status
         send_epg_update(epg_source.id, "parsing_programs", 100,
                       status="success",
-                      message=epg_source.last_message)
+                      message=epg_source.last_message,
+                      updated_at=epg_source.updated_at.isoformat())
 
         logger.info(f"Completed parsing programs for source: {epg_source.name} - "
                    f"{total_programs:,} programs for {channels_with_programs} channels, "
diff --git a/frontend/src/WebSocket.jsx b/frontend/src/WebSocket.jsx
index f2e28ae9..40035d33 100644
--- a/frontend/src/WebSocket.jsx
+++ b/frontend/src/WebSocket.jsx
@@ -574,7 +574,7 @@ export const WebsocketProvider = ({ children }) => {
                 const sourceId =
                   parsedEvent.data.source || parsedEvent.data.account;
                 const epg = epgs[sourceId];
-                
+
                 // Only update progress if the EPG still exists in the store
                 // This prevents crashes when receiving updates for deleted EPGs
                 if (epg) {
@@ -582,7 +582,9 @@ export const WebsocketProvider = ({ children }) => {
                   updateEPGProgress(parsedEvent.data);
                 } else {
                   // EPG was deleted, ignore this update
-                  console.debug(`Ignoring EPG refresh update for deleted EPG ${sourceId}`);
+                  console.debug(
+                    `Ignoring EPG refresh update for deleted EPG ${sourceId}`
+                  );
                   break;
                 }
 
@@ -621,6 +623,10 @@ export const WebsocketProvider = ({ children }) => {
                       status: parsedEvent.data.status || 'success',
                       last_message:
                         parsedEvent.data.message || epg.last_message,
+                      // Use the timestamp from the backend if provided
+                      ...(parsedEvent.data.updated_at && {
+                        updated_at: parsedEvent.data.updated_at,
+                      }),
                     });
 
                     // Only show success notification if we've finished parsing programs and had no errors

From 0d177e44f8ce8cdb2e7dba10bc9266f2b973849e Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Thu, 4 Dec 2025 15:45:09 -0600
Subject: [PATCH 15/26] changelog: Change updated change to bug fix instead of
 change.

---
 CHANGELOG.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8a77b7b7..0b95749e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,10 +15,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **Performance**: EPG program parsing optimized for sources with many channels but only a fraction mapped. Now parses XML file once per source instead of once per channel, dramatically reducing I/O and CPU overhead. For sources with 10,000 channels and 100 mapped, this results in ~99x fewer file opens and ~100x fewer full file scans. Orphaned programs for unmapped channels are also cleaned up during refresh to prevent database bloat. Database updates are now atomic to prevent clients from seeing empty/partial EPG data during refresh.
 - EPG table now displays detailed status messages including refresh progress, success messages, and last message for idle sources (matching M3U table behavior) (Closes #214)
-- EPG table "Updated" column now updates in real-time via WebSocket using the actual backend timestamp instead of requiring a page refresh
 - IPv6 access now allowed by default with all IPv6 CIDRs accepted - Thanks [@adrianmace](https://github.com/adrianmace)
 - nginx.conf updated to bind to both IPv4 and IPv6 ports - Thanks [@jordandalley](https://github.com/jordandalley)
 
+### Fixed
+
+- EPG table "Updated" column now updates in real-time via WebSocket using the actual backend timestamp instead of requiring a page refresh
+
 ## [0.13.0] - 2025-12-02
 
 ### Added

From c1d960138e4f455543caac34e0b6ef8ca16911e8 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Fri, 5 Dec 2025 09:02:03 -0600
Subject: [PATCH 16/26] Fix: Bulk channel editor confirmation dialog now shows
 the correct stream profile that will be set.

---
 CHANGELOG.md                                   | 1 +
 frontend/src/components/forms/ChannelBatch.jsx | 6 ++++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0b95749e..0b0223f9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 - EPG table "Updated" column now updates in real-time via WebSocket using the actual backend timestamp instead of requiring a page refresh
+- Bulk channel editor confirmation dialog now displays the correct stream profile name that will be applied to the selected channels.
 
 ## [0.13.0] - 2025-12-02
 
diff --git a/frontend/src/components/forms/ChannelBatch.jsx b/frontend/src/components/forms/ChannelBatch.jsx
index e42d418c..a1cebe54 100644
--- a/frontend/src/components/forms/ChannelBatch.jsx
+++ b/frontend/src/components/forms/ChannelBatch.jsx
@@ -135,8 +135,10 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
       if (values.stream_profile_id === '0') {
         changes.push(`• Stream Profile: Use Default`);
       } else {
-        const profileName =
-          streamProfiles[values.stream_profile_id]?.name || 'Selected Profile';
+        const profile = streamProfiles.find(
+          (p) => `${p.id}` === `${values.stream_profile_id}`
+        );
+        const profileName = profile?.name || 'Selected Profile';
         changes.push(`• Stream Profile: ${profileName}`);
       }
     }

From 759569b871973253c89dd7b625e1272fe5e9c7eb Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Fri, 5 Dec 2025 09:54:11 -0600
Subject: [PATCH 17/26] Enhancement: Add a priority field to EPGSource and
 prefer higher-priority sources when matching channels. Also ignore EPG
 sources where is_active is false during matching, and update
 serializers/forms/frontend accordingly.(Closes #603, #672)

---
 CHANGELOG.md                                  |  3 ++
 apps/channels/tasks.py                        | 37 ++++++++++++++-----
 .../epg/migrations/0021_epgsource_priority.py | 18 +++++++++
 apps/epg/models.py                            |  4 ++
 apps/epg/serializers.py                       |  1 +
 frontend/src/components/forms/EPG.jsx         | 28 ++++++++++----
 6 files changed, 73 insertions(+), 18 deletions(-)
 create mode 100644 apps/epg/migrations/0021_epgsource_priority.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0b0223f9..d58c0ce1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Sort buttons for 'Group' and 'M3U' columns in Streams table for improved stream organization and filtering - Thanks [@bobey6](https://github.com/bobey6)
+- EPG source priority field for controlling which EPG source is preferred when multiple sources have matching entries for a channel (higher numbers = higher priority) (Closes #603)
 
 ### Changed
 
@@ -17,6 +18,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - EPG table now displays detailed status messages including refresh progress, success messages, and last message for idle sources (matching M3U table behavior) (Closes #214)
 - IPv6 access now allowed by default with all IPv6 CIDRs accepted - Thanks [@adrianmace](https://github.com/adrianmace)
 - nginx.conf updated to bind to both IPv4 and IPv6 ports - Thanks [@jordandalley](https://github.com/jordandalley)
+- EPG matching now respects source priority and only uses active (enabled) EPG sources (Closes #672)
+- EPG form API Key field now only visible when Schedules Direct source type is selected
 
 ### Fixed
 
diff --git a/apps/channels/tasks.py b/apps/channels/tasks.py
index 5a9528a7..7ca73ac2 100755
--- a/apps/channels/tasks.py
+++ b/apps/channels/tasks.py
@@ -295,7 +295,11 @@ def match_channels_to_epg(channels_data, epg_data, region_code=None, use_ml=True
             if score > 50:  # Only show decent matches
                 logger.debug(f"  EPG '{row['name']}' (norm: '{row['norm_name']}') => score: {score} (base: {base_score}, bonus: {bonus})")
 
-            if score > best_score:
+            # When scores are equal, prefer higher priority EPG source
+            row_priority = row.get('epg_source_priority', 0)
+            best_priority = best_epg.get('epg_source_priority', 0) if best_epg else -1
+
+            if score > best_score or (score == best_score and row_priority > best_priority):
                 best_score = score
                 best_epg = row
 
@@ -471,9 +475,9 @@ def match_epg_channels():
                 "norm_chan": normalize_name(channel.name)  # Always use channel name for fuzzy matching!
             })
 
-        # Get all EPG data
+        # Get all EPG data from active sources, ordered by source priority (highest first) so we prefer higher priority matches
         epg_data = []
-        for epg in EPGData.objects.all():
+        for epg in EPGData.objects.select_related('epg_source').filter(epg_source__is_active=True):
             normalized_tvg_id = epg.tvg_id.strip().lower() if epg.tvg_id else ""
             epg_data.append({
                 'id': epg.id,
@@ -482,9 +486,13 @@ def match_epg_channels():
                 'name': epg.name,
                 'norm_name': normalize_name(epg.name),
                 'epg_source_id': epg.epg_source.id if epg.epg_source else None,
+                'epg_source_priority': epg.epg_source.priority if epg.epg_source else 0,
             })
 
-        logger.info(f"Processing {len(channels_data)} channels against {len(epg_data)} EPG entries")
+        # Sort EPG data by source priority (highest first) so we prefer higher priority matches
+        epg_data.sort(key=lambda x: x['epg_source_priority'], reverse=True)
+
+        logger.info(f"Processing {len(channels_data)} channels against {len(epg_data)} EPG entries (from active sources only)")
 
         # Run EPG matching with progress updates - automatically uses conservative thresholds for bulk operations
         result = match_channels_to_epg(channels_data, epg_data, region_code, use_ml=True, send_progress=True)
@@ -618,9 +626,9 @@ def match_selected_channels_epg(channel_ids):
                 "norm_chan": normalize_name(channel.name)
             })
 
-        # Get all EPG data
+        # Get all EPG data from active sources, ordered by source priority (highest first) so we prefer higher priority matches
         epg_data = []
-        for epg in EPGData.objects.all():
+        for epg in EPGData.objects.select_related('epg_source').filter(epg_source__is_active=True):
             normalized_tvg_id = epg.tvg_id.strip().lower() if epg.tvg_id else ""
             epg_data.append({
                 'id': epg.id,
@@ -629,9 +637,13 @@ def match_selected_channels_epg(channel_ids):
                 'name': epg.name,
                 'norm_name': normalize_name(epg.name),
                 'epg_source_id': epg.epg_source.id if epg.epg_source else None,
+                'epg_source_priority': epg.epg_source.priority if epg.epg_source else 0,
             })
 
-        logger.info(f"Processing {len(channels_data)} selected channels against {len(epg_data)} EPG entries")
+        # Sort EPG data by source priority (highest first) so we prefer higher priority matches
+        epg_data.sort(key=lambda x: x['epg_source_priority'], reverse=True)
+
+        logger.info(f"Processing {len(channels_data)} selected channels against {len(epg_data)} EPG entries (from active sources only)")
 
         # Run EPG matching with progress updates - automatically uses appropriate thresholds
         result = match_channels_to_epg(channels_data, epg_data, region_code, use_ml=True, send_progress=True)
@@ -749,9 +761,10 @@ def match_single_channel_epg(channel_id):
         test_normalized = normalize_name(test_name)
         logger.debug(f"DEBUG normalization example: '{test_name}' → '{test_normalized}' (call sign preserved)")
 
-        # Get all EPG data for matching - must include norm_name field
+        # Get all EPG data for matching from active sources - must include norm_name field
+        # Ordered by source priority (highest first) so we prefer higher priority matches
         epg_data_list = []
-        for epg in EPGData.objects.filter(name__isnull=False).exclude(name=''):
+        for epg in EPGData.objects.select_related('epg_source').filter(epg_source__is_active=True, name__isnull=False).exclude(name=''):
             normalized_epg_tvg_id = epg.tvg_id.strip().lower() if epg.tvg_id else ""
             epg_data_list.append({
                 'id': epg.id,
@@ -760,10 +773,14 @@ def match_single_channel_epg(channel_id):
                 'name': epg.name,
                 'norm_name': normalize_name(epg.name),
                 'epg_source_id': epg.epg_source.id if epg.epg_source else None,
+                'epg_source_priority': epg.epg_source.priority if epg.epg_source else 0,
             })
 
+        # Sort EPG data by source priority (highest first) so we prefer higher priority matches
+        epg_data_list.sort(key=lambda x: x['epg_source_priority'], reverse=True)
+
         if not epg_data_list:
-            return {"matched": False, "message": "No EPG data available for matching"}
+            return {"matched": False, "message": "No EPG data available for matching (from active sources)"}
 
         logger.info(f"Matching single channel '{channel.name}' against {len(epg_data_list)} EPG entries")
 
diff --git a/apps/epg/migrations/0021_epgsource_priority.py b/apps/epg/migrations/0021_epgsource_priority.py
new file mode 100644
index 00000000..f2696d67
--- /dev/null
+++ b/apps/epg/migrations/0021_epgsource_priority.py
@@ -0,0 +1,18 @@
+# Generated by Django 5.2.4 on 2025-12-05 15:24
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('epg', '0020_migrate_time_to_starttime_placeholders'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='epgsource',
+            name='priority',
+            field=models.PositiveIntegerField(default=0, help_text='Priority for EPG matching (higher numbers = higher priority). Used when multiple EPG sources have matching entries for a channel.'),
+        ),
+    ]
diff --git a/apps/epg/models.py b/apps/epg/models.py
index e5f3847b..b3696edc 100644
--- a/apps/epg/models.py
+++ b/apps/epg/models.py
@@ -45,6 +45,10 @@ class EPGSource(models.Model):
         null=True,
         help_text="Custom properties for dummy EPG configuration (regex patterns, timezone, duration, etc.)"
     )
+    priority = models.PositiveIntegerField(
+        default=0,
+        help_text="Priority for EPG matching (higher numbers = higher priority). Used when multiple EPG sources have matching entries for a channel."
+    )
     status = models.CharField(
         max_length=20,
         choices=STATUS_CHOICES,
diff --git a/apps/epg/serializers.py b/apps/epg/serializers.py
index bfb750fc..e4d5f466 100644
--- a/apps/epg/serializers.py
+++ b/apps/epg/serializers.py
@@ -24,6 +24,7 @@ class EPGSourceSerializer(serializers.ModelSerializer):
             'is_active',
             'file_path',
             'refresh_interval',
+            'priority',
             'status',
             'last_message',
             'created_at',
diff --git a/frontend/src/components/forms/EPG.jsx b/frontend/src/components/forms/EPG.jsx
index db4f8310..50c8553c 100644
--- a/frontend/src/components/forms/EPG.jsx
+++ b/frontend/src/components/forms/EPG.jsx
@@ -29,6 +29,7 @@ const EPG = ({ epg = null, isOpen, onClose }) => {
       api_key: '',
       is_active: true,
       refresh_interval: 24,
+      priority: 0,
     },
 
     validate: {
@@ -69,6 +70,7 @@ const EPG = ({ epg = null, isOpen, onClose }) => {
         api_key: epg.api_key,
         is_active: epg.is_active,
         refresh_interval: epg.refresh_interval,
+        priority: epg.priority ?? 0,
       };
       form.setValues(values);
       setSourceType(epg.source_type);
@@ -148,14 +150,24 @@ const EPG = ({ epg = null, isOpen, onClose }) => {
               key={form.key('url')}
             />
 
-            <TextInput
-              id="api_key"
-              name="api_key"
-              label="API Key"
-              description="API key for services that require authentication"
-              {...form.getInputProps('api_key')}
-              key={form.key('api_key')}
-              disabled={sourceType !== 'schedules_direct'}
+            {sourceType === 'schedules_direct' && (
+              <TextInput
+                id="api_key"
+                name="api_key"
+                label="API Key"
+                description="API key for services that require authentication"
+                {...form.getInputProps('api_key')}
+                key={form.key('api_key')}
+              />
+            )}
+
+            <NumberInput
+              min={0}
+              max={999}
+              label="Priority"
+              description="Priority for EPG matching (higher numbers = higher priority). Used when multiple EPG sources have matching entries for a channel."
+              {...form.getInputProps('priority')}
+              key={form.key('priority')}
             />
 
             {/* Put checkbox at the same level as Refresh Interval */}

From d0edc3fa072f726b3f6a6117a1ea16b38f8eeda3 Mon Sep 17 00:00:00 2001
From: dekzter <kappa118@gmail.com>
Date: Sun, 7 Dec 2025 07:54:30 -0500
Subject: [PATCH 18/26] remove permission lines to see if this resolves lack of
 django secret key in environment profile.d

---
 docker/entrypoint.sh | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/docker/entrypoint.sh b/docker/entrypoint.sh
index 9c3ec88c..df1584b0 100755
--- a/docker/entrypoint.sh
+++ b/docker/entrypoint.sh
@@ -52,9 +52,6 @@ PY
   mv -f "$tmpfile" "$SECRET_FILE" || { echo "move failed"; rm -f "$tmpfile"; exit 1; }
 fi
 
-chown $PUID:$PGID "$SECRET_FILE" || true
-chmod 600 "$SECRET_FILE" || true
-
 export DJANGO_SECRET_KEY="$(cat "$SECRET_FILE")"
 
 # Process priority configuration

From 3512c3a6233844b41ed2c8132bb0fdcfdf3f3740 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Sun, 7 Dec 2025 19:05:31 -0600
Subject: [PATCH 19/26] Add DJANGO_SECRET_KEY environment variable to uwsgi
 configuration files

---
 docker/uwsgi.debug.ini | 2 +-
 docker/uwsgi.dev.ini   | 1 +
 docker/uwsgi.ini       | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/docker/uwsgi.debug.ini b/docker/uwsgi.debug.ini
index 3de890a5..1d7cca93 100644
--- a/docker/uwsgi.debug.ini
+++ b/docker/uwsgi.debug.ini
@@ -20,7 +20,7 @@ module = scripts.debug_wrapper:application
 virtualenv = /dispatcharrpy
 master = true
 env = DJANGO_SETTINGS_MODULE=dispatcharr.settings
-
+env = DJANGO_SECRET_KEY=$(DJANGO_SECRET_KEY)
 socket = /app/uwsgi.sock
 chmod-socket = 777
 vacuum = true
diff --git a/docker/uwsgi.dev.ini b/docker/uwsgi.dev.ini
index e476e216..1ef9709e 100644
--- a/docker/uwsgi.dev.ini
+++ b/docker/uwsgi.dev.ini
@@ -22,6 +22,7 @@ module = dispatcharr.wsgi:application
 virtualenv = /dispatcharrpy
 master = true
 env = DJANGO_SETTINGS_MODULE=dispatcharr.settings
+env = DJANGO_SECRET_KEY=$(DJANGO_SECRET_KEY)
 socket = /app/uwsgi.sock
 chmod-socket = 777
 vacuum = true
diff --git a/docker/uwsgi.ini b/docker/uwsgi.ini
index f8fe8ab7..bb359b06 100644
--- a/docker/uwsgi.ini
+++ b/docker/uwsgi.ini
@@ -21,6 +21,7 @@ module = dispatcharr.wsgi:application
 virtualenv = /dispatcharrpy
 master = true
 env = DJANGO_SETTINGS_MODULE=dispatcharr.settings
+env = DJANGO_SECRET_KEY=$(DJANGO_SECRET_KEY)
 socket = /app/uwsgi.sock
 chmod-socket = 777
 vacuum = true

From cf37c6fd9869e8210589a8a99331da702030c2db Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Sun, 7 Dec 2025 19:06:45 -0600
Subject: [PATCH 20/26] changelog: Updated changelog for 0.13.1

---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index eb8324f1..90db90c6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- JWT token generated so is unique for each deployment
+
 ## [0.13.0] - 2025-12-02
 
 ### Added

From 2155229d7f0ce6ad079e3b802588822f1ef1b6b4 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Sun, 7 Dec 2025 19:40:32 -0600
Subject: [PATCH 21/26] Fix uwsgi command path in entrypoint script

---
 docker/entrypoint.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docker/entrypoint.sh b/docker/entrypoint.sh
index df1584b0..088bcd1e 100755
--- a/docker/entrypoint.sh
+++ b/docker/entrypoint.sh
@@ -200,7 +200,7 @@ fi
 # Users can override via UWSGI_NICE_LEVEL environment variable in docker-compose
 # Start with nice as root, then use setpriv to drop privileges to dispatch user
 # This preserves both the nice value and environment variables
-nice -n $UWSGI_NICE_LEVEL su -p - "$POSTGRES_USER" -c "cd /app && exec uwsgi $uwsgi_args" & uwsgi_pid=$!
+nice -n $UWSGI_NICE_LEVEL su - "$POSTGRES_USER" -c "cd /app && exec /dispatcharrpy/bin/uwsgi $uwsgi_args" & uwsgi_pid=$!
 echo "✅ uwsgi started with PID $uwsgi_pid (nice $UWSGI_NICE_LEVEL)"
 pids+=("$uwsgi_pid")
 

From e2736babaae4db7393560f7c1ae50d49a611baf9 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Sun, 7 Dec 2025 20:04:58 -0600
Subject: [PATCH 22/26] Reset umask after creating secret file.

---
 docker/entrypoint.sh | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/docker/entrypoint.sh b/docker/entrypoint.sh
index 088bcd1e..72eb5928 100755
--- a/docker/entrypoint.sh
+++ b/docker/entrypoint.sh
@@ -41,8 +41,10 @@ export DISPATCHARR_PORT=${DISPATCHARR_PORT:-9191}
 export LIBVA_DRIVERS_PATH='/usr/local/lib/x86_64-linux-gnu/dri'
 export LD_LIBRARY_PATH='/usr/local/lib'
 export SECRET_FILE="/data/jwt"
-
+# Ensure Django secret key exists or generate a new one
 if [ ! -f "$SECRET_FILE" ]; then
+  echo "Generating new Django secret key..."
+  old_umask=$(umask)
   umask 077
   tmpfile="$(mktemp "${SECRET_FILE}.XXXXXX")" || { echo "mktemp failed"; exit 1; }
   python3 - <<'PY' >"$tmpfile" || { echo "secret generation failed"; rm -f "$tmpfile"; exit 1; }
@@ -50,8 +52,8 @@ import secrets
 print(secrets.token_urlsafe(64))
 PY
   mv -f "$tmpfile" "$SECRET_FILE" || { echo "move failed"; rm -f "$tmpfile"; exit 1; }
+  umask $old_umask
 fi
-
 export DJANGO_SECRET_KEY="$(cat "$SECRET_FILE")"
 
 # Process priority configuration

From ce70b04097cb5fa0e52f500035fad4f7dcab73f5 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Sun, 7 Dec 2025 20:56:59 -0600
Subject: [PATCH 23/26] changelog: update changelog

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 90db90c6..8efdc30c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,6 +25,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - EPG table "Updated" column now updates in real-time via WebSocket using the actual backend timestamp instead of requiring a page refresh
 - Bulk channel editor confirmation dialog now displays the correct stream profile name that will be applied to the selected channels.
+- uWSGI not found and 502 bad gateway on first startup
 
 ## [0.13.1] - 2025-12-06
 

From c03ddf60a09175631e868bd5d647ba1484426ad2 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Sun, 7 Dec 2025 21:28:04 -0600
Subject: [PATCH 24/26] Fixed verbiage for epg parsing status.

---
 apps/epg/tasks.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/apps/epg/tasks.py b/apps/epg/tasks.py
index c565dbf5..bd78c6a3 100644
--- a/apps/epg/tasks.py
+++ b/apps/epg/tasks.py
@@ -1650,7 +1650,7 @@ def parse_programs_for_source(epg_source, tvg_id=None):
         epg_source.status = EPGSource.STATUS_SUCCESS
         epg_source.last_message = (
             f"Parsed {total_programs:,} programs for {channels_with_programs} channels "
-            f"(skipped {skipped_programs:,} programmes for {total_epg_count - mapped_count} unmapped channels)"
+            f"(skipped {skipped_programs:,} programs for {total_epg_count - mapped_count} unmapped channels)"
         )
         epg_source.updated_at = timezone.now()
         epg_source.save(update_fields=['status', 'last_message', 'updated_at'])
@@ -1672,8 +1672,8 @@ def parse_programs_for_source(epg_source, tvg_id=None):
                       updated_at=epg_source.updated_at.isoformat())
 
         logger.info(f"Completed parsing programs for source: {epg_source.name} - "
-                   f"{total_programs:,} programs for {channels_with_programs} channels, "
-                   f"skipped {skipped_programs:,} programmes for unmapped channels")
+               f"{total_programs:,} programs for {channels_with_programs} channels, "
+               f"skipped {skipped_programs:,} programs for unmapped channels")
         return True
 
     except Exception as e:

From 62f5c32609eb0c082c72897a9871559e69831d78 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Mon, 8 Dec 2025 17:27:07 -0600
Subject: [PATCH 25/26] Remove DJANGO_SECRET_KEY environment variable from
 uwsgi configuration files

---
 docker/uwsgi.debug.ini | 1 -
 docker/uwsgi.dev.ini   | 1 -
 docker/uwsgi.ini       | 1 -
 3 files changed, 3 deletions(-)

diff --git a/docker/uwsgi.debug.ini b/docker/uwsgi.debug.ini
index 1d7cca93..69c040f2 100644
--- a/docker/uwsgi.debug.ini
+++ b/docker/uwsgi.debug.ini
@@ -20,7 +20,6 @@ module = scripts.debug_wrapper:application
 virtualenv = /dispatcharrpy
 master = true
 env = DJANGO_SETTINGS_MODULE=dispatcharr.settings
-env = DJANGO_SECRET_KEY=$(DJANGO_SECRET_KEY)
 socket = /app/uwsgi.sock
 chmod-socket = 777
 vacuum = true
diff --git a/docker/uwsgi.dev.ini b/docker/uwsgi.dev.ini
index 1ef9709e..e476e216 100644
--- a/docker/uwsgi.dev.ini
+++ b/docker/uwsgi.dev.ini
@@ -22,7 +22,6 @@ module = dispatcharr.wsgi:application
 virtualenv = /dispatcharrpy
 master = true
 env = DJANGO_SETTINGS_MODULE=dispatcharr.settings
-env = DJANGO_SECRET_KEY=$(DJANGO_SECRET_KEY)
 socket = /app/uwsgi.sock
 chmod-socket = 777
 vacuum = true
diff --git a/docker/uwsgi.ini b/docker/uwsgi.ini
index bb359b06..f8fe8ab7 100644
--- a/docker/uwsgi.ini
+++ b/docker/uwsgi.ini
@@ -21,7 +21,6 @@ module = dispatcharr.wsgi:application
 virtualenv = /dispatcharrpy
 master = true
 env = DJANGO_SETTINGS_MODULE=dispatcharr.settings
-env = DJANGO_SECRET_KEY=$(DJANGO_SECRET_KEY)
 socket = /app/uwsgi.sock
 chmod-socket = 777
 vacuum = true

From 98b29f97a1df25395cf72cbb9612c54c06367870 Mon Sep 17 00:00:00 2001
From: SergeantPanda <chester.cullen@gmail.com>
Date: Mon, 8 Dec 2025 17:49:40 -0600
Subject: [PATCH 26/26] changelog: Update verbiage

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8efdc30c..347bb22a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,7 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- **Performance**: EPG program parsing optimized for sources with many channels but only a fraction mapped. Now parses XML file once per source instead of once per channel, dramatically reducing I/O and CPU overhead. For sources with 10,000 channels and 100 mapped, this results in ~99x fewer file opens and ~100x fewer full file scans. Orphaned programs for unmapped channels are also cleaned up during refresh to prevent database bloat. Database updates are now atomic to prevent clients from seeing empty/partial EPG data during refresh.
+- EPG program parsing optimized for sources with many channels but only a fraction mapped. Now parses XML file once per source instead of once per channel, dramatically reducing I/O and CPU overhead. For sources with 10,000 channels and 100 mapped, this results in ~99x fewer file opens and ~100x fewer full file scans. Orphaned programs for unmapped channels are also cleaned up during refresh to prevent database bloat. Database updates are now atomic to prevent clients from seeing empty/partial EPG data during refresh.
 - EPG table now displays detailed status messages including refresh progress, success messages, and last message for idle sources (matching M3U table behavior) (Closes #214)
 - IPv6 access now allowed by default with all IPv6 CIDRs accepted - Thanks [@adrianmace](https://github.com/adrianmace)
 - nginx.conf updated to bind to both IPv4 and IPv6 ports - Thanks [@jordandalley](https://github.com/jordandalley)