The Memory Multiplication Factor (1MB XML → 6.8MB Heap)

In BrightScript, every XML element, attribute, and text node is instantiated as a managed reference-counted object (roBrightScriptComponent). A standard program tag in an XMLTV file looks like this:

<programme start="20260925200000 +0000" stop="20260925220000 +0000" channel="UK_SkySports_MainEvent">
  <title lang="en">Live Premier League: Liverpool vs Arsenal</title>
  <desc lang="en">High-stakes clash live from Anfield with in-depth studio analysis.</desc>
  <category lang="en">Sports</category>
  <category lang="en">Football</category>
  <icon src="https://images.cdn.provider.tv/epg/match104.jpg" />
</programme>

While this block occupies roughly 340 bytes in a raw text file, the roXMLElement engine allocates 1 parent node, 5 child elements, 4 attribute hash-maps, and 5 string primitives. With object headers and pointer tables, this single broadcast listing consumes 2,312 bytes of RAM. Multiply that by 150,000 programs in a typical 7-day multi-country playlist, and the memory requirement surges to 346 megabytes—over five times the total allowable application heap of a Roku Express.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# High-Performance XMLTV Pruner for Roku Streaming Clients
# Reduces XMLTV payloads by >90% by stripping non-essential tags
# and limiting broadcast schedules to the next 48 hours.

import sys
import gzip
import datetime
from xml.etree import ElementTree as ET

def prune_xmltv_feed(source_path, output_gz_path, max_hours=48):
    now = datetime.datetime.now(datetime.timezone.utc)
    max_time = now + datetime.timedelta(hours=max_hours)
    cutoff_str = max_time.strftime("%Y%m%d%H%M%S")
    past_cutoff_str = (now - datetime.timedelta(hours=4)).strftime("%Y%m%d%H%M%S")

    # Tags to strip completely to protect Roku memory
    FORBIDDEN_TAGS = {'credits', 'cast', 'writer', 'director', 'producer', 
                      'country', 'episode-num', 'rating', 'star-rating', 
                      'sub-title', 'date', 'keyword'}

    print(f"[INFO]: Starting incremental parse of {source_path}...")
    
    with gzip.open(output_gz_path, 'wb', compresslevel=9) as out_f:
        out_f.write(b'<?xml version="1.0" encoding="UTF-8"?>
<tv>
')
        
        # Iterparse processes elements sequentially without loading the entire DOM into memory
        context = ET.iterparse(source_path, events=('end',))
        
        retained_channels = 0
        retained_programmes = 0
        
        for event, elem in context:
            if elem.tag == 'channel':
                # Retain channel ID and display-name only
                ch_id = elem.attrib.get('id', '')
                disp_name = elem.findtext('display-name') or ch_id
                icon = elem.find('icon')
                icon_src = icon.attrib.get('src', '') if icon is not None else ''
                
                ch_xml = f'  <channel id="{ch_id}"><display-name>{disp_name}</display-name>'
                if icon_src:
                    ch_xml += f'<icon src="{icon_src}"/>'
                ch_xml += '</channel>
'
                out_f.write(ch_xml.encode('utf-8'))
                retained_channels += 1
                elem.clear()

            elif elem.tag == 'programme':
                start_time = elem.attrib.get('start', '').split()[0]
                
                # Filter out programs outside our 48-hour viewing window
                if start_time and (start_time < past_cutoff_str or start_time > cutoff_str):
                    elem.clear()
                    continue
                
                # Strip bloated metadata nodes
                for child in list(elem):
                    if child.tag in FORBIDDEN_TAGS:
                        elem.remove(child)
                
                # Serialize pruned programme element
                elem_bytes = ET.tostring(elem, encoding='utf-8')
                out_f.write(b'  ' + elem_bytes + b'
')
                retained_programmes += 1
                elem.clear()
                
        out_f.write(b'</tv>
')
        
    print(f"[SUCCESS]: Retained {retained_channels} channels and {retained_programmes} programmes.")
    print(f"[SUCCESS]: Compressed output written to {output_gz_path}")

if __name__ == '__main__':
    prune_xmltv_feed('master_epg_raw.xml', 'roku_optimized_epg.xml.gz')

# Refresh master XMLTV guide every 4 hours, prune, and deploy to web root
0 */4 * * * curl -s "https://upstream.epg-provider.com/full_guide.xml" -o /tmp/raw_epg.xml &&             python3 /opt/epg_pruner/xmltv_pruner.py /tmp/raw_epg.xml /var/www/html/epg/roku_guide.xml.gz &&             rm -f /tmp/raw_epg.xml

location /epg/ {
    root /var/www/html;
    gzip_static on; # Serves pre-compressed .gz files without on-the-fly CPU load
    add_header Access-Control-Allow-Origin *;
    add_header Cache-Control "public, max-age=14400";
    types {
        text/xml xml;
        application/x-gzip gz;
    }
}

' DANGEROUS: Creates cyclic dependency that blocks reference counting deallocation
function CreateLeakyProgramItem(channelNode as Object, title as String) as Object
    prog = CreateObject("roSGNode", "ContentNode")
    prog.title = title
    prog.addField("parentChannel", "node", false)
    prog.parentChannel = channelNode ' Program points to Channel
    channelNode.appendChild(prog)    ' Channel points to Program
    return prog
end function

sub Init()
    m.top.functionName = "LoadAndParseEPG"
end sub

sub LoadAndParseEPG()
    urlTransfer = CreateObject("roUrlTransfer")
    urlTransfer.SetCertificatesFile("common:/certs/ca-bundle.crt")
    urlTransfer.InitClientCertificates()
    urlTransfer.SetUrl(m.top.epgUrl)
    
    ' Enable transparent gzip decompression over socket
    urlTransfer.EnableEncodings(true)
    
    xmlString = urlTransfer.GetToString()
    if xmlString <> "" then
        xmlDoc = CreateObject("roXMLElement")
        if xmlDoc.Parse(xmlString) then
            ' Parse channels and populate SceneGraph ContentNode in batches of 50
            m.top.parsedResult = BuildContentTree(xmlDoc)
        end if
    end if
end sub