From e72e7e3bd2bbc1e92f581fbb1a64b0607905336c Mon Sep 17 00:00:00 2001
From: Claudio Olmi <superolmo2@gmail.com>
Date: Thu, 26 Mar 2026 16:55:02 -0500
Subject: [PATCH 1/4] Init

---
 functional_test.py   |   4 +-
 pyxtream/__init__.py |   3 +-
 pyxtream/api.py      |  63 ++++++++++
 pyxtream/progress.py |  31 -----
 pyxtream/pyxtream.py | 287 ++++++++++++++++++-------------------------
 pyxtream/rest_api.py |  10 +-
 pyxtream/version.py  |   2 +-
 7 files changed, 194 insertions(+), 206 deletions(-)
 create mode 100644 pyxtream/api.py
 delete mode 100644 pyxtream/progress.py

diff --git a/functional_test.py b/functional_test.py
index 4242158..0b8e6d7 100755
--- a/functional_test.py
+++ b/functional_test.py
@@ -50,8 +50,10 @@ def str2list(input_string: str) -> list:
     PROVIDER_PASSWORD,
     PROVIDER_URL,
     reload_time_sec=60*60*8,
+    validate_json=False,
     debug_flask=True,
-    enable_flask=True
+    enable_flask=True,
+    flask_port=5000
     )
 
 sleep(0.5)
diff --git a/pyxtream/__init__.py b/pyxtream/__init__.py
index cf35465..c35de3e 100644
--- a/pyxtream/__init__.py
+++ b/pyxtream/__init__.py
@@ -1,6 +1,5 @@
 
-from .progress import progress
-from .pyxtream import XTream, Channel, Group, Serie, Episode
+from .pyxtream import Channel, Episode, Group, Serie, XTream
 
 try:
     from .rest_api import FlaskWrap
diff --git a/pyxtream/api.py b/pyxtream/api.py
new file mode 100644
index 0000000..c2cdd7a
--- /dev/null
+++ b/pyxtream/api.py
@@ -0,0 +1,63 @@
+"""
+API URL builders
+"""
+
+
+def get_live_categories_URL(base: str) -> str:
+    return f"{base}&action=get_live_categories"
+
+
+def get_live_streams_URL(base: str) -> str:
+    return f"{base}&action=get_live_streams"
+
+
+def get_live_streams_URL_by_category(category_id, base: str) -> str:
+    return f"{base}&action=get_live_streams&category_id={category_id}"
+
+
+def get_vod_cat_URL(base: str) -> str:
+    return f"{base}&action=get_vod_categories"
+
+
+def get_vod_streams_URL(base: str) -> str:
+    return f"{base}&action=get_vod_streams"
+
+
+def get_vod_streams_URL_by_category(category_id, base: str) -> str:
+    return f"{base}&action=get_vod_streams&category_id={category_id}"
+
+
+def get_series_cat_URL(base: str) -> str:
+    return f"{base}&action=get_series_categories"
+
+
+def get_series_URL(base: str) -> str:
+    return f"{base}&action=get_series"
+
+
+def get_series_URL_by_category(category_id, base: str) -> str:
+    return f"{base}&action=get_series&category_id={category_id}"
+
+
+def get_series_info_URL_by_ID(series_id, base: str) -> str:
+    return f"{base}&action=get_series_info&series_id={series_id}"
+
+
+def get_VOD_info_URL_by_ID(vod_id, base: str) -> str:
+    return f"{base}&action=get_vod_info&vod_id={vod_id}"
+
+
+def get_live_epg_URL_by_stream(stream_id, base: str) -> str:
+    return f"{base}&action=get_short_epg&stream_id={stream_id}"
+
+
+def get_live_epg_URL_by_stream_and_limit(stream_id, limit, base: str) -> str:
+    return f"{base}&action=get_short_epg&stream_id={stream_id}&limit={limit}"
+
+
+def get_all_live_epg_URL_by_stream(stream_id, base: str) -> str:
+    return f"{base}&action=get_simple_data_table&stream_id={stream_id}"
+
+
+def get_all_epg_URL(base: str, username: str, password: str) -> str:
+    return f"{base}/xmltv.php?username={username}&password={password}"
diff --git a/pyxtream/progress.py b/pyxtream/progress.py
deleted file mode 100644
index 6d93fa8..0000000
--- a/pyxtream/progress.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# The MIT License (MIT)
-# Copyright (c) 2016 Vladimir Ignatev
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the "Software"),
-# to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense,
-# and/or sell copies of the Software, and to permit persons to whom the Software
-# is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
-# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
-# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
-# OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
-# OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-import sys
-
-
-def progress(count, total, status=''):
-    bar_len = 60
-    filled_len = int(round(bar_len * count / float(total)))
-
-    percents = round(100.0 * count / float(total), 1)
-    bar_filled = '=' * filled_len + '-' * (bar_len - filled_len)
-
-    sys.stdout.write(f'[{bar_filled}] {percents}% ...{status}\r')
-    sys.stdout.flush()  # As suggested by Rom Ruben (see: http://stackoverflow.com/questions/3173320/text-progress-bar-in-the-console/27871113#comment50529068_27871113)
diff --git a/pyxtream/pyxtream.py b/pyxtream/pyxtream.py
index bbddf61..a1a2eec 100755
--- a/pyxtream/pyxtream.py
+++ b/pyxtream/pyxtream.py
@@ -18,18 +18,18 @@
 import json
 # used for URL validation
 import re
-import time
 import sys
+import time
+from datetime import datetime, timedelta
 from os import makedirs
 from os import path as osp
-
 # Timing xtream json downloads
 from timeit import default_timer as timer
-from typing import Tuple, Optional
-from datetime import datetime, timedelta
+from typing import Optional, Tuple
 import requests
 
 from pyxtream.schemaValidator import SchemaType, schemaValidator
+from pyxtream import api
 
 try:
     from pyxtream.rest_api import FlaskWrap
@@ -37,7 +37,7 @@
 except ImportError:
     USE_FLASK = False
 
-from pyxtream.progress import progress
+SSL_FIRST = True
 
 
 class Channel:
@@ -72,7 +72,8 @@ def __init__(self, xtream: object, group_title, stream_info):
             stream_type = "live"
 
         if stream_type not in ("live", "movie"):
-            print(f"Error the channel has unknown stream type `{stream_type}`\n`{stream_info}`")
+            print(f"Error the channel has unknown stream type "
+                  f"`{stream_type}`\n`{stream_info}`")
         else:
             # Raw JSON Channel
             self.raw = stream_info
@@ -174,7 +175,8 @@ def __init__(self, group_info: dict, stream_type: str):
         elif "Live" == stream_type:
             self.group_type = TV_GROUP
         else:
-            print(f"Unrecognized stream type `{stream_type}` for `{group_info}`")
+            print(f"Unrecognized stream type "
+                  f"`{stream_type}` for `{group_info}`")
 
         self.name = group_info["category_name"]
         split_name = self.name.split('|')
@@ -311,20 +313,6 @@ class XTream:
     vod_type = "VOD"
     series_type = "Series"
 
-    auth_data = {}
-    authorization = {'username': '', 'password': ''}
-
-    groups = []
-    channels = []
-    series = []
-    movies = []
-    movies_30days = []
-    movies_7days = []
-
-    connection_headers = {}
-
-    state = {'authenticated': False, 'loaded': False}
-
     hide_adult_content = False
 
     live_catch_all_group = Group(
@@ -342,9 +330,6 @@ class XTream:
 
     validate_json: bool = True
 
-    # Used by REST API to get download progress
-    download_progress: dict = {'StreamId': 0, 'Total': 0, 'Progress': 0}
-
     def __init__(
         self,
         provider_name: str,
@@ -357,7 +342,8 @@ def __init__(
         reload_time_sec: int = 60*60*8,
         validate_json: bool = False,
         enable_flask: bool = False,
-        debug_flask: bool = True
+        debug_flask: bool = True,
+        flask_port: int = 5000
             ):
         """Initialize Xtream Class
 
@@ -375,15 +361,16 @@ def __init__(
             validate_json     (bool, optional): Check Xtream API provided JSON for validity
             enable_flask      (bool, optional): Enable Flask
             debug_flask       (bool, optional): Enable the debug mode in Flask
+            flask_port        (int, optional):  Flask Port Number
 
         Returns: XTream Class Instance
 
         - Note 1: If it fails to authorize with provided username and password,
                 auth_data will be an empty dictionary.
         - Note 2: The JSON validation option will take considerable amount of time and it should be
-                  used only as a debug tool. The Xtream API JSON from the provider passes through a
-                  schema that represent the best available understanding of how the Xtream API
-                  works.
+                    used only as a debug tool. The Xtream API JSON from the provider passes through a
+                    schema that represent the best available understanding of how the Xtream API
+                    works.
         """
         self.server = provider_url
         self.username = provider_username
@@ -394,6 +381,23 @@ def __init__(
         self.threshold_time_sec = reload_time_sec
         self.validate_json = validate_json
 
+        self.auth_data = {}
+        self.authorization = {'username': '', 'password': ''}
+
+        self.groups = []
+        self.channels = []
+        self.series = []
+        self.movies = []
+        self.movies_30days = []
+        self.movies_7days = []
+
+        self.connection_headers = {}
+
+        self.state = {'authenticated': False, 'loaded': False}
+
+        # Used by REST API to get download progress
+        self.download_progress: dict = {'StreamId': 0, 'Total': 0, 'Progress': 0}
+
         # get the pyxtream local path
         self.app_fullpath = osp.dirname(osp.realpath(__file__))
 
@@ -404,7 +408,7 @@ def __init__(
         if self.cache_path != "":
             # If the cache_path is not a directory, clear it
             if not osp.isdir(self.cache_path):
-                print(" - Cache Path is not a directory, using default '~/.xtream-cache/'")
+                self.printx(" - Cache Path is not a directory, using default '~/.xtream-cache/'")
                 self.cache_path = ""
 
         # If the cache_path is still empty, use default
@@ -412,29 +416,34 @@ def __init__(
             self.cache_path = osp.expanduser("~/.xtream-cache/")
             if not osp.isdir(self.cache_path):
                 makedirs(self.cache_path, exist_ok=True)
-            print(f"pyxtream cache path located at {self.cache_path}")
+            self.printx(f"pyxtream cache path located at {self.cache_path}")
 
         if headers is not None:
             self.connection_headers = headers
         else:
-            self.connection_headers = {'User-Agent': "Wget/1.20.3 (linux-gnu)"}
+            self.connection_headers = {'User-Agent': "Mozilla/5.0"}
 
         self.authenticate()
 
-        if self.threshold_time_sec > 0:
-            print(f"Reload timer is ON and set to {self.threshold_time_sec} seconds")
-        else:
-            print("Reload timer is OFF")
-
         if self.state['authenticated']:
+            # Show message about Reload Timer configuration
+            if self.threshold_time_sec > 0:
+                self.printx(f"Reload timer is ON and set to {self.threshold_time_sec} seconds")
+            else:
+                self.printx("Reload timer is OFF")
+            # Start Flask Web Interface if enabled
             if USE_FLASK and enable_flask:
-                print("Starting Web Interface")
+                self.printx("Starting Web Interface")
                 self.flaskapp = FlaskWrap(
-                    'pyxtream', self, self.html_template_folder, debug=debug_flask
+                    self.name, self, self.html_template_folder,
+                    debug=debug_flask, port=flask_port
                     )
                 self.flaskapp.start()
             else:
-                print("Web interface not running")
+                self.printx("Web interface not running")
+
+    def printx(self, msg: str, end="\n", flush=True):
+        print(f"{self.name}: {msg}", end=end, flush=flush)
 
     def get_download_progress(self, stream_id: int = None):
         # TODO: Add check for stream specific ID
@@ -474,9 +483,9 @@ def search_stream(self, keyword: str,
         for stream_type_name in stream_type:
             if stream_type_name in stream_collections:
                 collection = stream_collections[stream_type_name]
-                print(f"Checking {len(collection)} {stream_type_name}")
+                self.printx(f"Checking {len(collection)} {stream_type_name}")
                 for stream in collection:
-                    if stream.name and re.match(regex, stream.name) is not None:
+                    if stream.name and regex.match(stream.name) is not None:
                         if added_after is None:
                             # Add all matches
                             search_result.append(stream.export_json())
@@ -484,11 +493,10 @@ def search_stream(self, keyword: str,
                             # Only add if it is more recent
                             pass
             else:
-                print(f"`{stream_type_name}` not found in collection")
+                self.printx(f"`{stream_type_name}` not found in collection")
 
         if return_type == "JSON":
-            # if search_result is not None:
-            print(f"Found {len(search_result)} results `{keyword}`")
+            self.printx(f"Found {len(search_result)} results `{keyword}`")
             return json.dumps(search_result, ensure_ascii=False)
 
         return search_result
@@ -536,7 +544,7 @@ def _download_video_impl(self, url: str, fullpath_filename: str) -> bool:
         ret_code = False
         mb_size = 1024*1024
         try:
-            print(f"Downloading from URL `{url}` and saving at `{fullpath_filename}`")
+            self.printx(f"Downloading from URL `{url}` and saving at `{fullpath_filename}`")
 
             # Check if the file already exists
             if osp.exists(fullpath_filename):
@@ -544,7 +552,7 @@ def _download_video_impl(self, url: str, fullpath_filename: str) -> bool:
                 file_size = osp.getsize(fullpath_filename)
                 self.connection_headers['Range'] = f'bytes={file_size}-'
                 mode = 'ab'  # Append to the existing file
-                print(f"Resuming from {file_size:_} bytes")
+                self.printx(f"Resuming from {file_size:_} bytes")
             else:
                 # If the file does not exist, start a new download
                 mode = 'wb'  # Write a new file
@@ -573,16 +581,16 @@ def _download_video_impl(self, url: str, fullpath_filename: str) -> bool:
                 # Set stream blocks
                 block_bytes = int(4*mb_size)     # 4 MB
 
-                print(
-                    f"Ready to download {total_content_size_mb:.1f} MB file ({total_content_size})"
-                    )
+                self.printx(f"Ready to download {total_content_size_mb:.1f} "
+                            f"MB file ({total_content_size})"
+                            )
                 if content_type.split('/')[0] != "text":
                     with open(fullpath_filename, mode) as file:
 
                         # Grab data by block_bytes
                         for data in response.iter_content(block_bytes, decode_unicode=False):
                             downloaded_bytes += block_bytes
-                            progress(downloaded_bytes, total_content_size, "Downloading")
+                            # progress(downloaded_bytes, total_content_size, "Downloading")
                             self.download_progress['Progress'] = downloaded_bytes
                             file.write(data)
 
@@ -594,14 +602,14 @@ def _download_video_impl(self, url: str, fullpath_filename: str) -> bool:
                     except KeyError:
                         pass
                 else:
-                    print(f"URL has a file with unexpected content-type {content_type}")
+                    self.printx(f"URL has a file with unexpected content-type {content_type}")
             else:
-                print(f"HTTP error {response.status_code} while retrieving from {url}")
+                self.printx(f"HTTP error {response.status_code} while retrieving from {url}")
         except requests.exceptions.ReadTimeout:
-            print("Read Timeout, try again")
+            self.printx("Read Timeout, try again")
         except Exception as e:
-            print("Unknown error")
-            print(e)
+            self.printx("Unknown error")
+            self.printx(e)
 
         return ret_code
 
@@ -663,7 +671,7 @@ def authenticate(self):
             r = None
             # Prepare the authentication url
             url = f"{self.server}/player_api.php?username={self.username}&password={self.password}"
-            print("Attempting connection... ", end='')
+            self.printx("Attempting connection... ", end='')
             while i < 30:
                 try:
                     # Request authentication, wait 4 seconds maximum
@@ -697,11 +705,12 @@ def authenticate(self):
                     if "https_port" in self.auth_data["server_info"]:
                         self.base_url_ssl = f"https://{self.auth_data['server_info']['url']}:{self.auth_data['server_info']['https_port']}" \
                                             f"/player_api.php?username={self.username}&password={self.password}"
-                    print(f"Account expires in {str(self.account_expiration)}")
+                    self.printx(f"Account expires in {str(self.account_expiration)}")
                 else:
-                    print(f"Provider `{self.name}` could not be loaded. Reason: `{r.status_code} {r.reason}`")
+                    print("")
+                    self.printx(f"Provider `{self.name}` could not be loaded. Reason: `{r.status_code} {r.reason}`")
             else:
-                print(f"\n{self.name}: Provider refused the connection")
+                self.printx(f"\n{self.name}: Provider refused the connection")
 
     def _load_from_file(self, filename) -> dict:
         """Try to load the dictionary from file
@@ -733,7 +742,7 @@ def _load_from_file(self, filename) -> dict:
                         if len(my_data) == 0:
                             my_data = None
                 except Exception as e:
-                    print(f" - Could not load from file `{full_filename}`: e=`{e}`")
+                    self.printx(f" - Could not load from file `{full_filename}`: e=`{e}`")
             return my_data
 
         return None
@@ -759,7 +768,7 @@ def _save_to_file(self, data_list: dict, filename: str) -> bool:
                 json.dump(data_list, file, ensure_ascii=False)
             return True
         except Exception as e:
-            print(f" - Could not save to file `{full_filename}`: e=`{e}`")
+            self.printx(f" - Could not save to file `{full_filename}`: e=`{e}`")
             return False
 
     def load_iptv(self) -> bool:
@@ -778,20 +787,20 @@ def load_iptv(self) -> bool:
         """
         # If pyxtream has not authenticated the connection, return empty
         if self.state["authenticated"] is False:
-            print("Warning, cannot load steams since authorization failed")
+            self.printx("Warning, cannot load steams since authorization failed")
             return False
 
         # If pyxtream has already loaded the data, skip and return success
         if self.state["loaded"] is True:
-            print("Warning, data has already been loaded.")
+            self.printx("Warning, data has already been loaded.")
             return True
 
         # Delete skipped channels from cache
         full_filename = osp.join(self.cache_path, "skipped_streams.json")
         try:
-            f = open(full_filename, mode="r+", encoding="utf-8")
-            f.truncate(0)
-            f.close()
+            with open(full_filename, mode="r+", encoding="utf-8") as f:
+                f.truncate(0)
+                f.close()
         except FileNotFoundError:
             pass
 
@@ -812,7 +821,7 @@ def load_iptv(self) -> bool:
 
             # If we got the GROUPS data, show the statistics and load GROUPS
             if all_cat is not None:
-                print(f"{self.name}: Loaded {len(all_cat)} {loading_stream_type} Groups in {dt:.3f} seconds")
+                self.printx(f"Loaded {len(all_cat)} {loading_stream_type} Groups in {dt:.3f} seconds")
                 # Add GROUPS to dictionaries
 
                 # Add the catch-all-errors group
@@ -836,7 +845,7 @@ def load_iptv(self) -> bool:
                 # Sort Categories
                 self.groups.sort(key=lambda x: x.name)
             else:
-                print(f" - Could not load {loading_stream_type} Groups")
+                self.printx(f" - Could not load {loading_stream_type} Groups")
                 break
 
             # Get Streams
@@ -854,43 +863,30 @@ def load_iptv(self) -> bool:
 
             # If we got the STREAMS data, show the statistics and load Streams
             if all_streams is not None:
-                print(f"{self.name}: Loaded {len(all_streams)} {loading_stream_type} Streams in {dt:.3f} seconds")
+                self.printx(f"Loaded {len(all_streams)} {loading_stream_type} Streams in {dt:.3f} seconds")
                 # Add Streams to dictionaries
 
                 skipped_adult_content = 0
                 skipped_no_name_content = 0
 
-                number_of_streams = len(all_streams)
-                current_stream_number = 0
-                # Calculate 1% of total number of streams
-                # This is used to slow down the progress bar
-                one_percent_number_of_streams = number_of_streams/100
+                self.printx(f"Processing {loading_stream_type} Streams...")
+
                 start = timer()
                 for stream_channel in all_streams:
                     skip_stream = False
-                    current_stream_number += 1
-
-                    # Show download progress every 1% of total number of streams
-                    if current_stream_number < one_percent_number_of_streams:
-                        progress(
-                            current_stream_number,
-                            number_of_streams,
-                            f"Processing {loading_stream_type} Streams"
-                            )
-                        one_percent_number_of_streams *= 2
 
                     # Validate JSON scheme
                     if self.validate_json:
                         if loading_stream_type == self.series_type:
                             if not schemaValidator(stream_channel, SchemaType.SERIES_INFO):
-                                print(stream_channel)
+                                self.printx(stream_channel)
                         elif loading_stream_type == self.live_type:
                             if not schemaValidator(stream_channel, SchemaType.LIVE):
-                                print(stream_channel)
+                                self.printx(stream_channel)
                         else:
                             # vod_type
                             if not schemaValidator(stream_channel, SchemaType.VOD):
-                                print(stream_channel)
+                                self.printx(stream_channel)
 
                     # Skip if the name of the stream is empty
                     if stream_channel["name"] == "":
@@ -951,13 +947,14 @@ def load_iptv(self) -> bool:
                                 stream_channel
                             )
 
-                        if new_channel.group_id == "9999":
-                            print(f" - xEverythingElse Channel -> {new_channel.name} - {new_channel.stream_type}")
-
                         # Save the new channel to the local list of channels
                         if loading_stream_type == self.live_type:
+                            if new_channel.group_id == "9999":
+                                self.printx(f" - xEverythingElse Channel -> {new_channel.name} - {new_channel.stream_type}")
                             self.channels.append(new_channel)
                         elif loading_stream_type == self.vod_type:
+                            if new_channel.group_id == "9999":
+                                self.printx(f" - xEverythingElse Channel -> {new_channel.name} - {new_channel.stream_type}")
                             self.movies.append(new_channel)
                             if new_channel.age_days_from_added < 31:
                                 self.movies_30days.append(new_channel)
@@ -973,16 +970,16 @@ def load_iptv(self) -> bool:
                             else:
                                 the_group.series.append(new_series)
                         else:
-                            print(f" - Group not found `{stream_channel['name']}`")
+                            self.printx(f" - Group not found `{stream_channel['name']}`")
                 print("\n")
                 # Print information of which streams have been skipped
                 if self.hide_adult_content:
-                    print(f" - Skipped {skipped_adult_content} adult {loading_stream_type} streams")
+                    self.printx(f" - Skipped {skipped_adult_content} adult {loading_stream_type} streams")
                 if skipped_no_name_content > 0:
-                    print(f" - Skipped {skipped_no_name_content} "
-                          "unprintable {loading_stream_type} streams")
+                    self.printx(f" - Skipped {skipped_no_name_content} "
+                                f"unprintable {loading_stream_type} streams")
             else:
-                print(f" - Could not load {loading_stream_type} Streams")
+                self.printx(f" - Could not load {loading_stream_type} Streams")
 
             self.state["loaded"] = True
         return True
@@ -1000,7 +997,7 @@ def _save_to_file_skipped_streams(self, stream_channel: Channel):
                 myfile.write('\n')
             return True
         except Exception as e:
-            print(f" - Could not save to skipped stream file `{full_filename}`: e=`{e}`")
+            self.printx(f" - Could not save to skipped stream file `{full_filename}`: e=`{e}`")
         return False
 
     def get_series_info_by_id(self, get_series: dict):
@@ -1032,16 +1029,16 @@ def get_series_info_by_id(self, get_series: dict):
     def _handle_request_exception(self, exception: requests.exceptions.RequestException):
         """Handle different types of request exceptions."""
         if isinstance(exception, requests.exceptions.ConnectionError):
-            print(" - Connection Error: Possible network problem \
+            self.printx(" - Connection Error: Possible network problem \
                   (e.g. DNS failure, refused connection, etc)")
         elif isinstance(exception, requests.exceptions.HTTPError):
-            print(" - HTTP Error")
+            self.printx(" - HTTP Error")
         elif isinstance(exception, requests.exceptions.TooManyRedirects):
-            print(" - TooManyRedirects")
+            self.printx(" - TooManyRedirects")
         elif isinstance(exception, requests.exceptions.ReadTimeout):
-            print(" - Timeout while loading data")
+            self.printx(" - Timeout while loading data")
         else:
-            print(f" - An unexpected error occurred: {exception}")
+            self.printx(f" - An unexpected error occurred: {exception}")
 
     def _get_request(self, url: str, timeout: Tuple[int, int] = (2, 15)) -> Optional[dict]:
         """Generic GET Request with Error handling
@@ -1081,7 +1078,7 @@ def _get_request(self, url: str, timeout: Tuple[int, int] = (2, 15)) -> Optional
             down_stats["bytes"] = 0
 
             # Set stream blocks
-            block_bytes = int(1*kb_size*kb_size)     # 4 MB
+            block_bytes = int(1*kb_size*kb_size)     # 1 MB
 
             # Grab data by block_bytes
             for data in response.iter_content(block_bytes, decode_unicode=False):
@@ -1090,16 +1087,16 @@ def _get_request(self, url: str, timeout: Tuple[int, int] = (2, 15)) -> Optional
                 down_stats["mbytes"] = down_stats["bytes"]/kb_size/kb_size
                 down_stats["delta_sec"] = time.perf_counter() - down_stats["start"]
                 download_speed_average = down_stats["kbytes"]//down_stats["delta_sec"]
-                sys.stdout.write(
-                    f'\rDownloading {down_stats["kbytes"]:.1f} MB at {download_speed_average:.0f} kB/s'
-                    )
+                # Show progress
+                msg = f'Downloading {down_stats["kbytes"]:.1f} MB at {download_speed_average:.0f} kB/s'
+                sys.stdout.write("\r" + msg)
                 sys.stdout.flush()
                 all_data.append(data)
-            print(" - Done")
+            self.printx(" - Done")
             full_content = b''.join(all_data)
             return json.loads(full_content)
 
-        print(f"HTTP error {response.status_code} while retrieving from {url}")
+        self.printx(f"HTTP error {response.status_code} while retrieving from {url}")
 
         return None
 
@@ -1115,11 +1112,11 @@ def _load_categories_from_provider(self, stream_type: str):
         """
         url = ""
         if stream_type == self.live_type:
-            url = self.get_live_categories_URL()
+            url = api.get_live_categories_URL(self.base_url)
         elif stream_type == self.vod_type:
-            url = self.get_vod_cat_URL()
+            url = api.get_vod_cat_URL(self.base_url)
         elif stream_type == self.series_type:
-            url = self.get_series_cat_URL()
+            url = api.get_series_cat_URL(self.base_url)
         else:
             url = ""
 
@@ -1137,11 +1134,11 @@ def _load_streams_from_provider(self, stream_type: str):
         """
         url = ""
         if stream_type == self.live_type:
-            url = self.get_live_streams_URL()
+            url = api.get_live_streams_URL(self.base_url)
         elif stream_type == self.vod_type:
-            url = self.get_vod_streams_URL()
+            url = api.get_vod_streams_URL(self.base_url)
         elif stream_type == self.series_type:
-            url = self.get_series_URL()
+            url = api.get_series_URL(self.base_url)
         else:
             url = ""
 
@@ -1161,11 +1158,11 @@ def _load_streams_by_category_from_provider(self, stream_type: str, category_id)
         url = ""
 
         if stream_type == self.live_type:
-            url = self.get_live_streams_URL_by_category(category_id)
+            url = api.get_live_streams_URL_by_category(category_id, self.base_url)
         elif stream_type == self.vod_type:
-            url = self.get_vod_streams_URL_by_category(category_id)
+            url = api.get_vod_streams_URL_by_category(category_id, self.base_url)
         elif stream_type == self.series_type:
-            url = self.get_series_URL_by_category(category_id)
+            url = api.get_series_URL_by_category(category_id, self.base_url)
         else:
             url = ""
 
@@ -1182,7 +1179,7 @@ def _load_series_info_by_id_from_provider(self, series_id: str, return_type: str
         Returns:
             [type]: JSON if successful, otherwise None
         """
-        data = self._get_request(self.get_series_info_URL_by_ID(series_id))
+        data = self._get_request(api.get_series_info_URL_by_ID(series_id, self.base_url))
         if return_type == "JSON":
             return json.dumps(data, ensure_ascii=False)
         return data
@@ -1195,67 +1192,21 @@ def _load_series_info_by_id_from_provider(self, series_id: str, return_type: str
 
     # GET VOD Info
     def vodInfoByID(self, vod_id):
-        return self._get_request(self.get_VOD_info_URL_by_ID(vod_id))
+        return self._get_request(api.get_VOD_info_URL_by_ID(vod_id, self.base_url), self.base_url)
 
     # GET short_epg for LIVE Streams (same as stalker portal,
     # prints the next X EPG that will play soon)
     def liveEpgByStream(self, stream_id):
-        return self._get_request(self.get_live_epg_URL_by_stream(stream_id))
+        return self._get_request(api.get_live_epg_URL_by_stream(stream_id, self.base_url))
 
     def liveEpgByStreamAndLimit(self, stream_id, limit):
-        return self._get_request(self.get_live_epg_URL_by_stream_and_limit(stream_id, limit))
+        return self._get_request(api.get_live_epg_URL_by_stream_and_limit(stream_id, limit, self.base_url))
 
     #  GET ALL EPG for LIVE Streams (same as stalker portal,
     # but it will print all epg listings regardless of the day)
     def allLiveEpgByStream(self, stream_id):
-        return self._get_request(self.get_all_live_epg_URL_by_stream(stream_id))
+        return self._get_request(api.get_all_live_epg_URL_by_stream(stream_id, self.base_url))
 
     # Full EPG List for all Streams
     def allEpg(self):
-        return self._get_request(self.get_all_epg_URL())
-
-    # URL-builder methods
-    def get_live_categories_URL(self) -> str:
-        return f"{self.base_url}&action=get_live_categories"
-
-    def get_live_streams_URL(self) -> str:
-        return f"{self.base_url}&action=get_live_streams"
-
-    def get_live_streams_URL_by_category(self, category_id) -> str:
-        return f"{self.base_url}&action=get_live_streams&category_id={category_id}"
-
-    def get_vod_cat_URL(self) -> str:
-        return f"{self.base_url}&action=get_vod_categories"
-
-    def get_vod_streams_URL(self) -> str:
-        return f"{self.base_url}&action=get_vod_streams"
-
-    def get_vod_streams_URL_by_category(self, category_id) -> str:
-        return f"{self.base_url}&action=get_vod_streams&category_id={category_id}"
-
-    def get_series_cat_URL(self) -> str:
-        return f"{self.base_url}&action=get_series_categories"
-
-    def get_series_URL(self) -> str:
-        return f"{self.base_url}&action=get_series"
-
-    def get_series_URL_by_category(self, category_id) -> str:
-        return f"{self.base_url}&action=get_series&category_id={category_id}"
-
-    def get_series_info_URL_by_ID(self, series_id) -> str:
-        return f"{self.base_url}&action=get_series_info&series_id={series_id}"
-
-    def get_VOD_info_URL_by_ID(self, vod_id) -> str:
-        return f"{self.base_url}&action=get_vod_info&vod_id={vod_id}"
-
-    def get_live_epg_URL_by_stream(self, stream_id) -> str:
-        return f"{self.base_url}&action=get_short_epg&stream_id={stream_id}"
-
-    def get_live_epg_URL_by_stream_and_limit(self, stream_id, limit) -> str:
-        return f"{self.base_url}&action=get_short_epg&stream_id={stream_id}&limit={limit}"
-
-    def get_all_live_epg_URL_by_stream(self, stream_id) -> str:
-        return f"{self.base_url}&action=get_simple_data_table&stream_id={stream_id}"
-
-    def get_all_epg_URL(self) -> str:
-        return f"{self.server}/xmltv.php?username={self.username}&password={self.password}"
+        return self._get_request(api.get_all_epg_URL(self.base_url, self.username, self.password))
diff --git a/pyxtream/rest_api.py b/pyxtream/rest_api.py
index 5086c2c..5d570c7 100644
--- a/pyxtream/rest_api.py
+++ b/pyxtream/rest_api.py
@@ -1,8 +1,12 @@
+"""
+Rest API
+"""
 
 # Import Flask to control IPTV via REST API
-from threading import Thread
 import logging
 from os import path
+from threading import Thread
+
 from flask import Flask
 from flask import Response as FlaskResponse
 
@@ -55,7 +59,7 @@ class FlaskWrap(Thread):
     host: str = ""
     port: int = 0
 
-    def __init__(self, name, xtream: object, html_template_folder: str = None,
+    def __init__(self, name, xtream: object, html_template_folder: str = "",
                  host: str = "0.0.0.0", port: int = 5000, debug: bool = True
                  ):
 
@@ -75,7 +79,7 @@ def __init__(self, name, xtream: object, html_template_folder: str = None,
         self.daemon = True
 
         # Load HTML Home Template if any
-        if html_template_folder is not None:
+        if html_template_folder != "":
             self.home_template_file_name = path.join(html_template_folder, "index.html")
             if path.isfile(self.home_template_file_name):
                 with open(self.home_template_file_name, 'r', encoding="utf-8") as home_html:
diff --git a/pyxtream/version.py b/pyxtream/version.py
index 0fea4f0..20002f6 100644
--- a/pyxtream/version.py
+++ b/pyxtream/version.py
@@ -1,4 +1,4 @@
 
-__version__ = '0.7.3'
+__version__ = '0.8.0'
 __author__ = 'Claudio Olmi'
 __author_email__ = 'superolmo2@gmail.com'

From 89687cf7a255c26703cbeef2ab34219868314e7f Mon Sep 17 00:00:00 2001
From: Claudio Olmi <superolmo2@gmail.com>
Date: Sat, 28 Mar 2026 16:51:34 -0500
Subject: [PATCH 2/4] Fixing workflow

---
 .github/workflows/run_pytest.yml |  2 +-
 test/test_pyxtream.py            | 22 ++++++++++++++++------
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/run_pytest.yml b/.github/workflows/run_pytest.yml
index e826202..ba9dd98 100644
--- a/.github/workflows/run_pytest.yml
+++ b/.github/workflows/run_pytest.yml
@@ -33,7 +33,7 @@ jobs:
         if [ -f test/requirements.txt ]; then pip install -r test/requirements.txt; fi
     - name: Check Syntax with flake8
       run: |
-        flake8 --extend-ignore=E501 pyxtream/pyxtream.py pyxtream/rest_api.py pyxtream/schemaValidator.py pyxtream/version.py pyxtream/progress.py
+        flake8 --extend-ignore=E501 pyxtream/pyxtream.py pyxtream/rest_api.py pyxtream/schemaValidator.py pyxtream/version.py pyxtream/api.py
     - name: Test with pytest
       run: |
         python3 -m pytest --cov=pyxtream test/test_pyxtream.py
diff --git a/test/test_pyxtream.py b/test/test_pyxtream.py
index 8d19a2b..552de26 100644
--- a/test/test_pyxtream.py
+++ b/test/test_pyxtream.py
@@ -1,19 +1,19 @@
 # test_pyxtream.py
 import os
+import sys
 from datetime import datetime, timedelta
 from unittest.mock import Mock, patch
 
 import pytest
 
-import sys
 sys.path.insert(0, '../pyxtream')
 from pyxtream import Channel, Episode, Group, Serie, XTream
 
 # Mock data for provider connection
 mock_provider_name = "Test Provider"
-mock_provider_username = "test_user" # Must be the same as in the MOCK_AUTH_DATA
-mock_provider_password = "test_pass" # Must be the same as in the MOCK_AUTH_DATA
-mock_provider_url = "http://test.server.com" # Must be the same as in the MOCK_AUTH_DATA
+mock_provider_username = "test_user"            # Must be the same as in the MOCK_AUTH_DATA
+mock_provider_password = "test_pass"            # Must be the same as in the MOCK_AUTH_DATA
+mock_provider_url = "http://test.server.com"    # Must be the same as in the MOCK_AUTH_DATA
 
 
 # Mock data for testing
@@ -52,6 +52,7 @@
     }
 }
 
+
 # Fixture for environment setup
 @pytest.fixture(autouse=True)
 def setup_environment(monkeypatch):
@@ -67,7 +68,7 @@ def mock_xtream():
     with patch('requests.get') as mock_get:
         mock_get.return_value.ok = True
         mock_get.return_value.json.return_value = MOCK_AUTH_DATA
-        USE_FLASK=False
+        USE_FLASK = False
         xtream = XTream(
             provider_name=mock_provider_name,
             provider_username=mock_provider_username,
@@ -76,11 +77,13 @@ def mock_xtream():
         )
         return xtream
 
+
 def test_authentication(mock_xtream):
     assert mock_xtream.state["authenticated"] is True
     assert mock_xtream.authorization["username"] == mock_provider_username
     assert mock_xtream.authorization["password"] == mock_provider_password
 
+
 def test_channel_initialization(mock_xtream):
     stream_info = {
         "stream_id": "123",
@@ -100,6 +103,7 @@ def test_channel_initialization(mock_xtream):
         f"{mock_provider_url}/live/{mock_provider_username}/{mock_provider_password}/123.ts"
         )
 
+
 def test_group_initialization():
     group_info = {"category_id": 1, "category_name": "Live TV"}
     group = Group(group_info, "Live")
@@ -107,6 +111,7 @@ def test_group_initialization():
     assert group.name == "Live TV"
     assert group.group_type == 0  # TV_GROUP
 
+
 def test_serie_initialization(mock_xtream):
     series_info = {
         "series_id": 1,
@@ -130,6 +135,7 @@ def test_serie_initialization(mock_xtream):
     assert isinstance(serie.seasons, dict)
     assert isinstance(serie.episodes, dict)
 
+
 def test_episode_initialization(mock_xtream):
     series_info = {"cover": f"{mock_provider_url}/cover.jpg"}
     episode_info = {
@@ -143,6 +149,7 @@ def test_episode_initialization(mock_xtream):
     assert episode.id == 1
     assert episode.title == "Episode 1"
 
+
 def test_load_categories(mock_xtream):
     with patch.object(mock_xtream, '_get_request', return_value=MOCK_CATEGORIES) as mock_get:
         # Test live categories
@@ -150,22 +157,25 @@ def test_load_categories(mock_xtream):
         assert len(categories) == 2
         assert categories[0]["category_name"] == "Live TV"
 
+
 def test_load_streams(mock_xtream):
     with patch.object(mock_xtream, '_get_request', return_value=MOCK_STREAMS) as mock_get:
-        
         # Test live streams
         streams = mock_xtream._load_streams_from_provider(mock_xtream.live_type)
         assert len(streams) == 2
         assert streams[0]["name"] == "Channel 1"
 
+
 def test_validate_url(mock_xtream):
     assert mock_xtream._validate_url("http://valid.url") is True
     assert mock_xtream._validate_url("invalid.url") is False
 
+
 def test_slugify(mock_xtream):
     assert mock_xtream._slugify("Test String!") == "test string!"
     assert mock_xtream._slugify("123ABC") == "123abc"
 
+
 def test_get_logo_local_path(mock_xtream):
     logo_url = f"{mock_provider_url}/logo.png"
     expected_path = os.path.join(

From 1ef363f6a2ab88f0c960f3976ad8aca5428537d7 Mon Sep 17 00:00:00 2001
From: Claudio Olmi <superolmo2@gmail.com>
Date: Fri, 3 Apr 2026 20:30:12 -0500
Subject: [PATCH 3/4] More improvements

---
 pyxtream/__init__.py        |   2 +-
 pyxtream/html/index.html    | 429 ++++++++++++++++++++++--------------
 pyxtream/pyxtream.py        |  85 +++----
 pyxtream/rest_api.py        |   4 +-
 pyxtream/schemaValidator.py |   3 +-
 test/test_pyxtream.py       | 168 ++++++++++++--
 6 files changed, 464 insertions(+), 227 deletions(-)

diff --git a/pyxtream/__init__.py b/pyxtream/__init__.py
index c35de3e..f586bba 100644
--- a/pyxtream/__init__.py
+++ b/pyxtream/__init__.py
@@ -1,5 +1,5 @@
 
-from .pyxtream import Channel, Episode, Group, Serie, XTream
+from .pyxtream import Channel, Episode, Group, Season, Serie, XTream
 
 try:
     from .rest_api import FlaskWrap
diff --git a/pyxtream/html/index.html b/pyxtream/html/index.html
index 22af5b2..c4be097 100644
--- a/pyxtream/html/index.html
+++ b/pyxtream/html/index.html
@@ -15,9 +15,40 @@
     <script src="https://cdn.jsdelivr.net/npm/video.js@8.21.0/dist/video.min.js"></script>
     <style>
         .card {
-        width: 200px;
-        margin: 10px;
-        padding: 8px;
+            width: 200px;
+            height: 480px;
+            margin: 10px;
+            perspective: 1000px;
+            transform-style: preserve-3d;
+            transition: transform 0.6s;
+            cursor: pointer;
+            position: relative;
+            border: none;
+            background: transparent;
+        }
+
+        .card.is-flipped {
+            transform: rotateY(180deg);
+        }
+
+        .face {
+            position: absolute;
+            width: 100%;
+            height: 100%;
+            backface-visibility: hidden;
+            -webkit-backface-visibility: hidden;
+            border: 1px solid rgba(0,0,0,.125);
+            border-radius: .375rem;
+            background: white;
+            padding: 8px;
+            top: 0;
+            left: 0;
+        }
+
+        .back {
+            transform: rotateY(180deg);
+            background-color: #f8f9fa;
+            overflow-y: auto;
         }
 
         .card-img-top {
@@ -80,7 +111,7 @@
 </head>
 
 <body>
-    <nav class="navbar navbar-expand navbar-dark sticky-top bg-dark">
+    <nav class="navbar navbar-expand navbar-dark sticky-top bg-dark" id="mainNavbar">
         <div class="container">
             <a class="navbar-brand" href="#">PyXtream</a>
             <div class="dropdown">
@@ -109,20 +140,19 @@
 
             </div>
         </div>
-        <div class="modal" id="myModal" tabindex="-1">
-            <div class="modal-dialog modal-dialog-centered">
+        <div class="modal fade" id="myModal" tabindex="-1">
+            <div class="modal-dialog modal-lg modal-dialog-centered">
                 <div class="modal-content">
-                    <div class="modal-body">
+                    <div class="modal-header">
+                        <h5 class="modal-title">Stream Player</h5>
+                        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                    </div>
+                    <div class="modal-body" id="video_container">
                         <video id="video_player_id" class="video-js"></video>
                     </div>
                 </div>
             </div>
         </div>
-        <nav aria-label="Page navigation" class="mt-4">
-            <ul class="pagination justify-content-center" id="pagination">
-                <!-- Pagination items will be dynamically added here -->
-            </ul>
-        </nav>
     </main>
 </body>
 
@@ -146,6 +176,14 @@ <h5 class="card-title" id="stream_title"></h5>
                 </button>
             </div>
         </div>
+        <div class="face back d-flex flex-column">
+            <div class="card-body">
+                <h5 class="card-title text-center" id="back_stream_title"></h5>
+                <hr>
+                <p class="card-text text-start" id="back_stream_plot" style="font-size: 0.75rem;"></p>
+                <div id="back_stream_details" class="text-start" style="font-size: 0.7rem;"></div>
+            </div>
+        </div>
     </div>
 `;
 var html_card_movie = `
@@ -170,12 +208,24 @@ <h5 class="card-title" id="stream_title"></h5>
                 </button>
             </div>
         </div>
+        <div class="face back d-flex flex-column">
+            <div class="card-body">
+                <h5 class="card-title text-center" id="back_stream_title"></h5>
+                <hr>
+                <p class="card-text text-start" id="back_stream_plot" style="font-size: 0.75rem;"></p>
+                <div id="back_stream_details" class="text-start" style="font-size: 0.7rem;"></div>
+            </div>
+        </div>
     </div>
 `;
 var ribbon_div = "<div class='ribbon'></div>";
 
-var session_data = []
-var session_paging = {"currentPage": 1, "itemsPerPage": 40, "totalPages": 1}
+const API_BASE_URL = "http://localhost:5000";
+var all_streams_data = []; // Stores all fetched streams
+var displayed_streams_count = 0; // How many streams are currently displayed
+const streamsPerLoad = 40; // Number of streams to load at a time
+var isLoading = false; // Flag to prevent multiple simultaneous loads
+var hasMoreData = true; // Flag to indicate if there are more streams to load
 
 var isoCountries = {
     'AF' : 'Afghanistan',
@@ -508,7 +558,7 @@ <h5 class="card-title" id="stream_title"></h5>
 function htmlToElement(html) {
     var template = document.createElement('template');
     template.innerHTML = html.trim();
-    return template.content; //.firstChild;
+    return template.content.firstChild; // Return the actual element
 }
 
 /**
@@ -518,29 +568,14 @@ <h5 class="card-title" id="stream_title"></h5>
  */
 function buildMovieCard(item)
 {
-    var page_country = document.getElementById("countryDropdown").value;
+    var page_country = document.getElementById("countryDropdown").innerText;
     var card_info = "";
 
+    var card; // Declare card here to be accessible after switch
     /*** Get all the card content from item object ***/
     switch (item.stream_type) {
         case "live":
-        case "created_live":
-
-// added: "1715964817"
-// category_id: "834"
-// container_extension: "mp4"
-// custom_sid: ""
-// direct_source: ""
-// is_adult: 0
-// logo_path: "/home/superolmo/.xtream-cache/alibaba-dxxm3lldjgrc50i5rhvfqziskan_big.jpg"
-// name: "EN| Pompeii"
-// num: 8611
-// rating: "5.528"
-// rating_5based: 2.8
-// stream_icon: "http://a985.xyz:900/images/dxxM3lLDjGRC50i5rhvfQziskAN_big.jpg"
-// stream_id: 401208728
-// stream_type: "movie"
-// url: "http://fqcnndg.mexamo.xyz:80/movie/9769452694/5301927423/401208728.mp4"         
+        case "created_live":  
         case "movie":
             var card = htmlToElement(html_card_movie);
             var card_front = card.querySelector('.front');
@@ -568,25 +603,6 @@ <h5 class="card-title" id="stream_title"></h5>
         case undefined:
             // If stream_id is undefined, it is not a Movie, it is a Series
 
-
-// cast: "Wendy Richard, Valerie Leon, Frankie Howerd, Elizabeth Larner, Jeanne Mockford, Max Adrian, Russell Hunter, Wallas Eaton"
-// category_id: "1502"
-// cover: "http://a985.xyz:900/images/zrRmxQH2Gr2pX3DP2Lu7LC2cdjy_big.jpg"
-// director: ""
-// episode_run_time: "30"
-// genre: "Comedy"
-// last_modified: "1675863716"
-// added: "1675863716"
-// logo_path: "/home/superolmo/.xtream-cache/alibaba-zrrmxqh2gr2px3dp2lu7lc2cdjy_big.jpg"
-// name: "EN| Up Pompeii!"
-// num: 12183
-// plot: "Up Pompeii! is a British television comedy series broadcast between 1969 and 1970, starring Frankie Howerd. The first series was written by Talbot Rothwell, a scriptwriter for the Carry On films, and the second series by Rothwell and Sid Colin. Two later specials were transmitted in 1975 and 1991."
-// rating: "8"
-// rating_5based: 4
-// releaseDate: "1970-03-30"
-// series_id: 16448
-// youtube_trailer: ""
-
             var card = htmlToElement(html_card_series);
             var card_front = card.querySelector('.front');
             // var card_back = card.querySelector('.back');
@@ -628,9 +644,47 @@ <h5 class="card-title" id="stream_title"></h5>
     card_front.querySelector("#stream_title").innerHTML = stream_title;
     
     if ((stream_type == "series") || (stream_type == undefined)) {
+        // Populate back of series card
+        const card_back = card.querySelector('.back');
+        if (card_back) {
+            card_back.querySelector('#back_stream_title').textContent = stream_title;
+            if (item.plot) {
+                card_back.querySelector('#back_stream_plot').textContent = item.plot;
+            } else {
+                card_back.querySelector('#back_stream_plot').style.display = 'none';
+            }
+            let detailsHtml = '';
+            if (item.genre) detailsHtml += `<strong>Genre:</strong> ${item.genre}<br>`;
+            if (item.rating) detailsHtml += `<strong>Rating:</strong> ${item.rating}/${item.rating_5based}<br>`;
+            if (item.releaseDate) detailsHtml += `<strong>Release Date:</strong> ${item.releaseDate}<br>`;
+            if (item.director) detailsHtml += `<strong>Director:</strong> ${item.director}<br>`;
+            if (item.cast) detailsHtml += `<strong>Cast:</strong> ${item.cast}<br>`;
+            if (item.duration) detailsHtml += `<strong>Duration:</strong> ${item.duration} min<br>`;
+            card_back.querySelector('#back_stream_details').innerHTML = detailsHtml;
+        }
+
         card_front.querySelector("#open_series_btn").style.visibility = 'visible';
         card_front.querySelector('.open_series').setAttribute("series_id", stream_id);
     } else {
+        // Populate back of movie card
+        const card_back = card.querySelector('.back');
+        if (card_back) {
+            card_back.querySelector('#back_stream_title').textContent = stream_title;
+            if (item.plot) {
+                card_back.querySelector('#back_stream_plot').textContent = item.plot;
+            } else {
+                card_back.querySelector('#back_stream_plot').style.display = 'none';
+            }
+            let detailsHtml = '';
+            if (item.genre) detailsHtml += `<strong>Genre:</strong> ${item.genre}<br>`;
+            if (item.rating) detailsHtml += `<strong>Rating:</strong> ${item.rating}<br>`;
+            if (item.release_date) detailsHtml += `<strong>Release Date:</strong> ${item.release_date}<br>`;
+            if (item.director) detailsHtml += `<strong>Director:</strong> ${item.director}<br>`;
+            if (item.cast) detailsHtml += `<strong>Cast:</strong> ${item.cast}<br>`;
+            if (item.duration) detailsHtml += `<strong>Duration:</strong> ${item.duration} min<br>`;
+            card_back.querySelector('#back_stream_details').innerHTML = detailsHtml;
+        }
+
         card_front.querySelector("#play_video_btn").style.visibility = 'visible';
         card_front.querySelector('.play_movie').setAttribute("movie_url", stream_url);
         card_front.querySelector('.play_movie').setAttribute("movie_extension", stream_extension);
@@ -653,44 +707,12 @@ <h5 class="card-title" id="stream_title"></h5>
     if (page_country == undefined)
         return card;
 
-    if ((page_country == stream_country) || (page_country == "All Countries") || (page_country == ""))
+    if ((page_country == shortToLongLanguage(stream_country)) || (page_country == "All Countries") || (page_country == ""))
         return card;
 
     return "";
 }
 
-function renderPagination() {
-    const pagination = document.getElementById('pagination');
-    pagination.innerHTML = '';
-
-    // Previous button
-    const prevItem = document.createElement('li');
-    prevItem.className = `page-item ${session_paging.currentPage === 1 ? 'disabled' : ''}`;
-    prevItem.innerHTML = `<a class="page-link" href="#" onclick="changePage(${session_paging.currentPage - 1})">Previous</a>`;
-    pagination.appendChild(prevItem);
-
-    // Page numbers
-    for (let i = 1; i <= session_paging.totalPages; i++) {
-        const pageItem = document.createElement('li');
-        pageItem.className = `page-item ${i === session_paging.currentPage ? 'active' : ''}`;
-        pageItem.innerHTML = `<a class="page-link" href="#" onclick="changePage(${i})">${i}</a>`;
-        pagination.appendChild(pageItem);
-    }
-
-    // Next button
-    const nextItem = document.createElement('li');
-    nextItem.className = `page-item ${session_paging.currentPage === session_paging.totalPages ? 'disabled' : ''}`;
-    nextItem.innerHTML = `<a class="page-link" href="#" onclick="changePage(${session_paging.currentPage + 1})">Next</a>`;
-    pagination.appendChild(nextItem);
-}
-
-function changePage(render_page) {
-    if (render_page < 1 || render_page > session_paging.totalPages) return;
-    buildAllCardsFromSearch(render_page);
-    session_paging.currentPage = render_page;
-    renderPagination();
-}
-
 /**
  * Send search string to server, get the result, and prepare output in search_result element
  * @param {integer} page number
@@ -701,43 +723,65 @@ <h5 class="card-title" id="stream_title"></h5>
     if (document.getElementById("searchString_INPUT").value == "")
         return ""
 
-    url = "http://localhost:5000/stream_search/" + document.getElementById("searchString_INPUT").value
+    url = API_BASE_URL + "/stream_search/" + document.getElementById("searchString_INPUT").value
 
     if (document.getElementById("searchStringType_INPUT").value != "")
     {
         url = url + "/" + document.getElementById("searchStringType_INPUT").value
     }
 
+    isLoading = true; // Set loading flag
     const response = await fetch(url);
-    session_data = await response.json();
-    console.log(`Found ${session_data.length} streams`);
+    all_streams_data = await response.json();
+    isLoading = false; // Unlock so loadAndRenderNextBatch can run
+    console.log(`Found ${all_streams_data.length} streams`);
 
-    /* Sort session_data by field added ascending */
-    session_data.sort(function(a, b){
+    /* Sort all_streams_data by field added ascending */
+    all_streams_data.sort(function(a, b){
         return b.added - a.added;
     });
 
-    // Calculate pagination values
-    session_paging.totalPages = Math.ceil(session_data.length / session_paging.itemsPerPage);
-    session_paging.currentPage = 1;
-    
-    buildAllCardsFromSearch(1);
-    renderPagination();
+    displayed_streams_count = 0; // Reset count for new search
+    hasMoreData = true; // Assume there's more data initially
+    document.getElementById("search_results").innerHTML = "<div class='row row-cols-1 row-cols-md-2 g-4'></div>"; // Clear existing cards and create the row container
+
+    loadAndRenderNextBatch(); // Load the first batch
 }
 
-function buildAllCardsFromSearch(render_page = 1)
-{
-    // Calculate start and end indices
-    const startIndex = (render_page - 1) * session_paging.itemsPerPage;
-    const endIndex = startIndex + session_paging.itemsPerPage;
-    const pageData = session_data.slice(startIndex, endIndex);
+/**
+ * Loads and renders the next batch of streams from all_streams_data.
+ */
+function loadAndRenderNextBatch() {
+    if (isLoading || !hasMoreData) {
+        return;
+    }
+
+    isLoading = true;
+
+    const startIndex = displayed_streams_count;
+    const endIndex = Math.min(displayed_streams_count + streamsPerLoad, all_streams_data.length);
+    const streamsToRender = all_streams_data.slice(startIndex, endIndex);
+
+    if (streamsToRender.length > 0) {
+        appendCardsToDOM(streamsToRender);
+        displayed_streams_count += streamsToRender.length;
+    }
 
-    var searchResults = document.getElementById("search_results");
-    searchResults.innerHTML = "<div class='row row-cols-1 row-cols-md-2 g-4'></div>"
-    var searchResultsRow = searchResults.firstChild;
+    if (displayed_streams_count >= all_streams_data.length) {
+        hasMoreData = false;
+    }
+
+    isLoading = false;
+}
 
-    /* For every result stream, prepare and add a card to the search result div*/
-    pageData.every(item => {
+/**
+ * Appends a batch of stream cards to the DOM.
+ * @param {Array} streams The array of stream objects to append.
+ */
+function appendCardsToDOM(streams) {
+    var searchResultsRow = document.querySelector("#search_results .row");
+
+    streams.forEach(item => {
         const newCard = buildMovieCard(item);
         if (newCard) {
             searchResultsRow.appendChild(newCard);
@@ -745,33 +789,23 @@ <h5 class="card-title" id="stream_title"></h5>
         return true;
     });
 
-    /* Attach to card body */
-    var cb_elements = document.getElementsByClassName("card-body");
-    for (i = 0; i < cb_elements.length; i++)
-    {
-        cb_elements[i].addEventListener('click', manage_card_events);
-    }
-
-    /* Attach to play movie */
-    var pm_elements = document.getElementsByClassName("play_movie");
-    for (i = 0; i < pm_elements.length; i++)
-    {
-        pm_elements[i].addEventListener('click', play_movie_action);
-    }
-
-    /* Attach to download movie */
-    var dm_elements = document.getElementsByClassName("download_movie");
-    for (i = 0; i < dm_elements.length; i++)
-    {
-        dm_elements[i].addEventListener('click',download_movie_action);
-    }
-
-    /* Attach to open series */
-    var os_elements = document.getElementsByClassName("open_series");
-    for (i = 0; i < os_elements.length; i++)
-    {
-        os_elements[i].addEventListener('click',open_series_action);
-    }
+    // Attach listeners to newly added elements (avoiding duplicates)
+    searchResultsRow.querySelectorAll(".card-body:not(.has-listener)").forEach(el => {
+        el.addEventListener('click', manage_card_events);
+        el.classList.add('has-listener');
+    });
+    searchResultsRow.querySelectorAll(".play_movie:not(.has-listener)").forEach(el => {
+        el.addEventListener('click', play_movie_action);
+        el.classList.add('has-listener');
+    });
+    searchResultsRow.querySelectorAll(".download_movie:not(.has-listener)").forEach(el => {
+        el.addEventListener('click', download_movie_action);
+        el.classList.add('has-listener');
+    });
+    searchResultsRow.querySelectorAll(".open_series:not(.has-listener)").forEach(el => {
+        el.addEventListener('click', open_series_action);
+        el.classList.add('has-listener');
+    });
 }
 
 /**
@@ -790,24 +824,24 @@ <h5 class="card-title" id="stream_title"></h5>
  * Get the stream URL from element and pass it to video player
  * @param {event} event Element event
  */
- async function get_last_7days_action(event) {
-    url = "http://localhost:5000/get_last_7days"
+async function get_last_7days_action(event) {
+    url = API_BASE_URL + "/get_last_7days"
 
+    isLoading = true; // Set loading flag
     const response = await fetch(url);
-    session_data = await response.json();
-    console.log(`Found ${session_data.length} streams`);
+    all_streams_data = await response.json();
+    isLoading = false; // Unlock so loadAndRenderNextBatch can run
+    console.log(`Found ${all_streams_data.length} streams`);
 
     /* Sort page_data by field added ascending */
-    session_data.sort(function(a, b){
+    all_streams_data.sort(function(a, b){
         return b.added - a.added;
     });
 
-    // Calculate pagination values
-    session_paging.totalPages = Math.ceil(session_data.length / session_paging.itemsPerPage);
-    session_paging.currentPage = 1;
-
-    buildAllCardsFromSearch(1);
-    renderPagination();
+    displayed_streams_count = 0; // Reset count for new search
+    hasMoreData = true; // Assume there's more data initially
+    document.getElementById("search_results").innerHTML = "<div class='row row-cols-1 row-cols-md-2 g-4'></div>"; // Clear existing cards and create the row container
+    loadAndRenderNextBatch(); // Load the first batch
 }
 
 /**
@@ -815,37 +849,64 @@ <h5 class="card-title" id="stream_title"></h5>
  * @param {event} event Element event
  */
 async function download_movie_action(event) {
-    //TODO: Add code to download movie
-    console.log("Call the download API for movie ID " + event.currentTarget.attributes.movie_id.value)
-    url = "http://localhost:5000/download_stream/" + event.currentTarget.attributes.movie_id.value
-    const response = await fetch(url);
-    session_data = await response.json();
-    if (response.status != 200)
-    {
-        console.log("Error, could not retrieve data");
-        console.log(response);
-    }
-    //Render DATA
-    console.log(session_data)
+    const btn = event.currentTarget;
+    const movie_id = btn.getAttribute("movie_id");
+    const originalHtml = btn.innerHTML;
+    const downloadUrl = `${API_BASE_URL}/download_stream/movie/${movie_id}/`;
+
+    console.log(`Initiating download for movie ID: ${movie_id}`);
+
+    // Trigger the download. We do not await this because the backend call is blocking.
+    fetch(downloadUrl).then(response => {
+        if (!response.ok) console.error("Download request failed");
+    }).catch(err => console.error("Error starting download:", err));
+
+    // UI feedback: disable button and start polling
+    btn.disabled = true;
+    
+    const progressInterval = setInterval(async () => {
+        const progressUrl = `${API_BASE_URL}/get_download_progress/${movie_id}/`;
+        try {
+            const response = await fetch(progressUrl);
+            const stats = await response.json();
+
+            if (stats.Total > 0) {
+                const percent = Math.min(100, Math.round((stats.Progress / stats.Total) * 100));
+                btn.innerHTML = `<span style="font-size: 0.75rem;">${percent}%</span>`;
+
+                if (percent >= 100) {
+                    clearInterval(progressInterval);
+                    btn.innerHTML = `<i class="bi bi-check-lg text-success"></i>`;
+                    btn.disabled = false;
+                    setTimeout(() => { btn.innerHTML = originalHtml; }, 5000);
+                }
+            }
+        } catch (error) {
+            console.error("Polling error:", error);
+            clearInterval(progressInterval);
+            btn.disabled = false;
+            btn.innerHTML = originalHtml;
+        }
+    }, 1000);
 }
 
 /**
  * Get the stream URL from element and pass it to video player
  * @param {event} event Element event
  */
- async function open_series_action(event) {
+async function open_series_action(event) {
     //TODO: Add code to open the series
     console.log("Call the open series API for series ID " + event.currentTarget.attributes.series_id.value)
-    url = "http://localhost:5000/get_series/" + event.currentTarget.attributes.series_id.value;
+    url = API_BASE_URL + "/get_series/" + event.currentTarget.attributes.series_id.value;
     const response = await fetch(url);
-    session_data = await response.json();
-    if (response.status != 200)
+    const series_data = await response.json(); // Renamed to avoid conflict with all_streams_data
+    if (response.status !== 200)
     {
         console.log("Error, could not retrieve data");
         console.log(response);
     }
     //Render DATA
-    console.log(session_data)
+    console.log(series_data)
 }
 
 /**
@@ -860,6 +921,12 @@ <h5 class="card-title" id="stream_title"></h5>
 
     if (allowed_extensions.includes(movie_extension))
     {
+        // If a player already exists, dispose of it to avoid conflicts
+        if (videojs.getPlayers()['video_player_id']) {
+            videojs('video_player_id').dispose();
+            document.getElementById('video_container').innerHTML = '<video id="video_player_id" class="video-js vjs-theme-city"></video>';
+        }
+
         var myPlayer = videojs('video_player_id', {liveui: true, controls: true, autoplay: true});
         myPlayer.aspectRatio('16:9');
         myPlayer.fluid(true);
@@ -871,9 +938,6 @@ <h5 class="card-title" id="stream_title"></h5>
             mime_type = "video/webm";
         }
         myPlayer.src({ type: mime_type, src: movie_url });
-        document.getElementById('myModal').addEventListener('hidden.bs.modal', function (event) {
-            videojs.players.video_player_id.pause()
-        })
 
         var myVideoModal = new bootstrap.Modal(document.getElementById('myModal'));
         myVideoModal.show();
@@ -904,6 +968,24 @@ <h5 class="card-title" id="stream_title"></h5>
 {
   var dropdownButton = document.querySelector('#countryDropdown');
   dropdownButton.innerHTML = txt;
+  localStorage.setItem('pyxtream_selectedCountry', txt); // Save to localStorage
+}
+
+// Properly dispose of the video player when the modal is closed
+document.getElementById('myModal').addEventListener('hidden.bs.modal', function (event) {
+    if (videojs.getPlayers()['video_player_id']) {
+        videojs('video_player_id').dispose();
+        // Re-create the video element because .dispose() removes it from the DOM
+        document.getElementById('video_container').innerHTML = '<video id="video_player_id" class="video-js vjs-theme-city"></video>';
+    }
+});
+
+// Scroll event handler for infinite scrolling
+function handleScroll() {
+    // Check if user is near the bottom of the page (e.g., within 500px)
+    if ((window.innerHeight + window.scrollY) >= (document.body.offsetHeight - 500)) {
+        loadAndRenderNextBatch();
+    }
 }
 
 // Call the function to generate the dropdown when the page loads
@@ -913,5 +995,22 @@ <h5 class="card-title" id="stream_title"></h5>
 document.getElementById("searchString_INPUT").addEventListener('keypress', logKey);
 document.getElementById("searchString_BTN").addEventListener('click', fetchSearchResults);
 document.getElementById("last7days_BTN").addEventListener('click', get_last_7days_action);
+window.addEventListener('scroll', handleScroll);
+
+// Initial load when the page first loads
+document.addEventListener('DOMContentLoaded', (event) => {
+    // Load selected country from localStorage on page load
+    const savedCountry = localStorage.getItem('pyxtream_selectedCountry');
+    if (savedCountry) {
+        updateDropDownButtonLabel(savedCountry);
+    }
+
+    // Trigger an initial search or load some default content
+    // For now, let's just load the first batch if all_streams_data is empty
+    // In a real app, you might have a default search or "recently added" list
+    if (all_streams_data.length === 0) {
+        get_last_7days_action(); // Load "7 Days" content by default
+    }
+});
 
 </script>
\ No newline at end of file
diff --git a/pyxtream/pyxtream.py b/pyxtream/pyxtream.py
index a1a2eec..7d1afe2 100755
--- a/pyxtream/pyxtream.py
+++ b/pyxtream/pyxtream.py
@@ -20,16 +20,17 @@
 import re
 import sys
 import time
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from os import makedirs
 from os import path as osp
 # Timing xtream json downloads
 from timeit import default_timer as timer
 from typing import Optional, Tuple
+
 import requests
 
-from pyxtream.schemaValidator import SchemaType, schemaValidator
 from pyxtream import api
+from pyxtream.schemaValidator import SchemaType, schemaValidator
 
 try:
     from pyxtream.rest_api import FlaskWrap
@@ -61,10 +62,10 @@ class Channel:
     date_now: datetime
 
     # This contains the raw JSON data
-    raw = ""
+    raw: dict = {}
 
     def __init__(self, xtream: object, group_title, stream_info):
-        self.date_now = datetime.now()
+        self.date_now = datetime.now(timezone.utc)
 
         stream_type = stream_info["stream_type"]
         # Adjust the odd "created_live" type
@@ -112,7 +113,7 @@ def __init__(self, xtream: object, group_title, stream_info):
 
             self.added = int(stream_info["added"])
             self.age_days_from_added = abs(
-                datetime.utcfromtimestamp(self.added) - self.date_now
+                datetime.fromtimestamp(self.added, timezone.utc) - self.date_now
                 ).days
 
             # Required by Hypnotix
@@ -142,7 +143,7 @@ class Group:
     group_id = ""
 
     # This contains the raw JSON data
-    raw = ""
+    raw: dict = {}
 
     def convert_region_shortname_to_fullname(self, shortname):
 
@@ -200,7 +201,7 @@ class Episode:
     # XTream
 
     # This contains the raw JSON data
-    raw = ""
+    raw: dict = {}
 
     def __init__(self, xtream: object, series_info, group_title, episode_info) -> None:
         # Raw JSON Episode
@@ -239,7 +240,7 @@ class Serie:
     genre = ""
 
     # This contains the raw JSON data
-    raw = ""
+    raw: dict = {}
 
     def __init__(self, xtream: object, series_info):
 
@@ -452,6 +453,9 @@ def get_download_progress(self, stream_id: int = None):
     def get_last_7days(self):
         return json.dumps(self.movies_7days, default=lambda x: x.export_json())
 
+    def get_last_30days(self):
+        return json.dumps(self.movies_30days, default=lambda x: x.export_json())
+
     def search_stream(self, keyword: str,
                       ignore_case: bool = True,
                       return_type: str = "LIST",
@@ -501,35 +505,40 @@ def search_stream(self, keyword: str,
 
         return search_result
 
-    def download_video(self, stream_id: int) -> str:
+    def download_video(self, stream_type: str, stream_id: int) -> str:
         """Download Video from Stream ID
 
         Args:
             stream_id (int): String identifying the stream ID
 
         Returns:
-            str: Absolute Path Filename where the file was saved. Empty if could not download
+            str: Absolute Path Filename where the file was saved. Empty string if could not download
         """
         url = ""
         filename = ""
-        for series_stream in self.series:
-            if series_stream.series_id == stream_id:
-                episode_object: Episode = series_stream.episodes["1"]
-                url = f"{series_stream.url}/{episode_object.id}."\
-                      f"{episode_object.container_extension}"
-
-        for stream in self.movies:
-            if stream.id == stream_id:
-                url = stream.url
-                fn = f"{self._slugify(stream.name)}.{stream.raw['container_extension']}"
-                filename = osp.join(self.cache_path, fn)
+        if stream_type == "series":
+            for series_stream in self.series:
+                if series_stream.series_id == stream_id:
+                    episode_object: Episode = series_stream.episodes["1"]
+                    url = f"{series_stream.url}/{episode_object.id}."\
+                        f"{episode_object.container_extension}"
+
+        if stream_type == "movie":
+            for stream in self.movies:
+                if stream.id == stream_id:
+                    url = stream.url
+                    fn = f"{self._slugify(stream.name)}.{stream.raw['container_extension']}"
+                    filename = osp.join(self.cache_path, fn)
 
         # If the url was correctly built and file does not exists, start downloading
-        if url != "":
-            if not self._download_video_impl(url, filename):
-                return "Error"
+        if url == "":
+            return ""
 
-        return filename
+        for attempt in range(10):
+            if self._download_video_impl(url, filename):
+                return filename
+
+        return ""
 
     def _download_video_impl(self, url: str, fullpath_filename: str) -> bool:
         """Download a stream
@@ -543,6 +552,7 @@ def _download_video_impl(self, url: str, fullpath_filename: str) -> bool:
         """
         ret_code = False
         mb_size = 1024*1024
+        headers = self.connection_headers.copy()
         try:
             self.printx(f"Downloading from URL `{url}` and saving at `{fullpath_filename}`")
 
@@ -550,7 +560,7 @@ def _download_video_impl(self, url: str, fullpath_filename: str) -> bool:
             if osp.exists(fullpath_filename):
                 # If the file exists, resume the download from where it left off
                 file_size = osp.getsize(fullpath_filename)
-                self.connection_headers['Range'] = f'bytes={file_size}-'
+                headers['Range'] = f'bytes={file_size}-'
                 mode = 'ab'  # Append to the existing file
                 self.printx(f"Resuming from {file_size:_} bytes")
             else:
@@ -562,7 +572,7 @@ def _download_video_impl(self, url: str, fullpath_filename: str) -> bool:
                 url, timeout=(10),
                 stream=True,
                 allow_redirects=True,
-                headers=self.connection_headers
+                headers=headers
                 )
             # If there is an answer from the remote server
             if response.status_code in (200, 206):
@@ -595,12 +605,6 @@ def _download_video_impl(self, url: str, fullpath_filename: str) -> bool:
                             file.write(data)
 
                     ret_code = True
-
-                    # Delete Range if it was added
-                    try:
-                        del self.connection_headers['Range']
-                    except KeyError:
-                        pass
                 else:
                     self.printx(f"URL has a file with unexpected content-type {content_type}")
             else:
@@ -694,7 +698,7 @@ def authenticate(self):
                     # Account expiration date
                     self.account_expiration = timedelta(
                         seconds=(
-                            int(self.auth_data["user_info"]["exp_date"])-datetime.now().timestamp()
+                            int(self.auth_data["user_info"]["exp_date"])-datetime.now(timezone.utc).timestamp()
                         )
                     )
                     # Mark connection authorized
@@ -1056,6 +1060,7 @@ def _get_request(self, url: str, timeout: Tuple[int, int] = (2, 15)) -> Optional
         all_data = []
         down_stats = {"bytes": 0, "kbytes": 0, "mbytes": 0, "start": 0.0, "delta_sec": 0.0}
 
+        response = None
         for attempt in range(10):
             try:
                 response = requests.get(
@@ -1071,7 +1076,7 @@ def _get_request(self, url: str, timeout: Tuple[int, int] = (2, 15)) -> Optional
                 return None
 
         # If there is an answer from the remote server
-        if response.status_code in (200, 206):
+        if response is not None and response.status_code in (200, 206):
             down_stats["start"] = time.perf_counter()
 
             # Set downloaded size
@@ -1086,13 +1091,17 @@ def _get_request(self, url: str, timeout: Tuple[int, int] = (2, 15)) -> Optional
                 down_stats["kbytes"] = down_stats["bytes"]/kb_size
                 down_stats["mbytes"] = down_stats["bytes"]/kb_size/kb_size
                 down_stats["delta_sec"] = time.perf_counter() - down_stats["start"]
-                download_speed_average = down_stats["kbytes"]//down_stats["delta_sec"]
+                if down_stats["delta_sec"] > 0:
+                    download_speed_average = down_stats["kbytes"] // down_stats["delta_sec"]
+                else:
+                    download_speed_average = 0
                 # Show progress
-                msg = f'Downloading {down_stats["kbytes"]:.1f} MB at {download_speed_average:.0f} kB/s'
+                msg = f'Downloading {down_stats["kbytes"]:.1f} kB at {download_speed_average:.0f} kB/s'
                 sys.stdout.write("\r" + msg)
                 sys.stdout.flush()
                 all_data.append(data)
-            self.printx(" - Done")
+            sys.stdout.write(" - Done\n")
+            sys.stdout.flush()
             full_content = b''.join(all_data)
             return json.loads(full_content)
 
diff --git a/pyxtream/rest_api.py b/pyxtream/rest_api.py
index 5d570c7..a363646 100644
--- a/pyxtream/rest_api.py
+++ b/pyxtream/rest_api.py
@@ -29,7 +29,7 @@ def __call__(self, **args):
             # Add handlers here
             "stream_search_generic": lambda: self._handle_search(args['term']),
             "stream_search_with_type": lambda: self._handle_search(args['term'], args.get('type')),
-            "download_stream": lambda: self.action(int(args['stream_id'])),
+            "download_stream": lambda: self.action(str(args['stream_type']), int(args['stream_id'])),
             "get_download_progress": lambda: self.action(int(args['stream_id'])),
             "get_last_7days": lambda: self.action(),
             "home": lambda: self.action,
@@ -95,7 +95,7 @@ def __init__(self, name, xtream: object, html_template_folder: str = "",
                           endpoint_name='stream_search_with_type',
                           handler=[self.xt.search_stream, 'stream_search_with_type']
                           )
-        self.add_endpoint(endpoint='/download_stream/<stream_id>/',
+        self.add_endpoint(endpoint='/download_stream/<stream_type>/<stream_id>/',
                           endpoint_name='download_stream',
                           handler=[self.xt.download_video, "download_stream"]
                           )
diff --git a/pyxtream/schemaValidator.py b/pyxtream/schemaValidator.py
index 1645729..174121d 100644
--- a/pyxtream/schemaValidator.py
+++ b/pyxtream/schemaValidator.py
@@ -1,5 +1,6 @@
 
 from enum import Enum
+from typing import Any
 
 from jsonschema import exceptions, validate
 
@@ -276,7 +277,7 @@ class SchemaType(Enum):
 }
 
 
-def schemaValidator(jsonData: str, schemaType: SchemaType) -> bool:
+def schemaValidator(jsonData: Any, schemaType: SchemaType) -> bool:
 
     if (schemaType == SchemaType.SERIES):
         json_schema = series_schema
diff --git a/test/test_pyxtream.py b/test/test_pyxtream.py
index 552de26..b37803b 100644
--- a/test/test_pyxtream.py
+++ b/test/test_pyxtream.py
@@ -1,13 +1,15 @@
 # test_pyxtream.py
+
+import json
 import os
 import sys
 from datetime import datetime, timedelta
-from unittest.mock import Mock, patch
+from unittest.mock import Mock, mock_open, patch
 
 import pytest
 
-sys.path.insert(0, '../pyxtream')
-from pyxtream import Channel, Episode, Group, Serie, XTream
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from pyxtream import Channel, Episode, Group, Season, Serie, XTream
 
 # Mock data for provider connection
 mock_provider_name = "Test Provider"
@@ -35,37 +37,42 @@
 ]
 
 MOCK_STREAMS = [
-    {"stream_id": 1, "name": "Channel 1", "stream_type": "live", "category_id": 1,
+    {"num": 1, "stream_id": 1, "name": "Channel 1", "stream_type": "live", "category_id": "1",
      "stream_icon": f"{mock_provider_url}/icon1.png", "added": "1638316800"},
-    {"stream_id": 2, "name": "Movie 1", "stream_type": "movie", "category_id": 2,
-     "stream_icon": f"{mock_provider_url}/icon2.png", "added": "1638316800"}
+    {"num": 2, "stream_id": 2, "name": "Movie 1", "stream_type": "movie", "category_id": "2",
+     "stream_icon": f"{mock_provider_url}/icon2.png", "added": "1638316800", "container_extension": "mp4"}
+]
+
+MOCK_SERIES = [
+    {
+        "num": 1, "name": "Test Series", "series_id": 1, "last_modified": "1638316800",
+        "cover": f"{mock_provider_url}/cover.jpg", "plot": "Test plot", "cast": "Test cast",
+        "director": "Test director", "genre": "Action", "releaseDate": "2021-01-01",
+        "rating": "5", "category_id": "1"
+    }
 ]
 
 MOCK_SERIES_INFO = {
     "seasons": [
-        {"season_number": 1, "name": "Season 1", "cover": f"{mock_provider_url}/cover1.jpg"}
+        {"season_number": 1, "name": "Season 1",
+         "cover": f"{mock_provider_url}/cover1.jpg"}
     ],
     "episodes": {
         "1": [
-            {"id": 1, "title": "Episode 1", "container_extension": "mp4", "info": {}}
+            {"id": 1, "title": "Episode 1", "container_extension": "mp4",
+             "info": {}, "episode_num": 1}
         ]
     }
 }
 
 
 # Fixture for environment setup
-@pytest.fixture(autouse=True)
-def setup_environment(monkeypatch):
-    """Setup environment before each test."""
-    # Mock the cache directory
-    monkeypatch.setattr("pyxtream.XTream.cache_path", "/tmp/pyxtream_cache")
-    # Ensure the cache directory exists
-    os.makedirs("/tmp/pyxtream_cache", exist_ok=True)
-
-
 @pytest.fixture(scope="module")
-def mock_xtream():
-    with patch('requests.get') as mock_get:
+def mock_xtream(tmp_path_factory):
+    cache_dir = tmp_path_factory.mktemp("xtream_cache")
+    # Patching dirname and expanduser to avoid touching real home dirs
+    with patch('requests.get') as mock_get, \
+         patch('os.path.expanduser', return_value=str(cache_dir)):
         mock_get.return_value.ok = True
         mock_get.return_value.json.return_value = MOCK_AUTH_DATA
         USE_FLASK = False
@@ -73,7 +80,8 @@ def mock_xtream():
             provider_name=mock_provider_name,
             provider_username=mock_provider_username,
             provider_password=mock_provider_password,
-            provider_url=mock_provider_url
+            provider_url=mock_provider_url,
+            cache_path=str(cache_dir)
         )
         return xtream
 
@@ -104,6 +112,14 @@ def test_channel_initialization(mock_xtream):
         )
 
 
+def test_channel_export_json(mock_xtream):
+    stream_info = {"stream_id": "1", "name": "C1", "stream_icon": "icon", "stream_type": "live", "category_id": "1", "added": "1638316800"}
+    channel = Channel(mock_xtream, "Group", stream_info)
+    exported = channel.export_json()
+    assert exported["url"] == channel.url
+    assert exported["logo_path"] == channel.logo_path
+
+
 def test_group_initialization():
     group_info = {"category_id": 1, "category_name": "Live TV"}
     group = Group(group_info, "Live")
@@ -112,6 +128,13 @@ def test_group_initialization():
     assert group.group_type == 0  # TV_GROUP
 
 
+def test_group_region_names():
+    group_info = {"category_name": "AR | Arab TV"}
+    group = Group(group_info, "Live")
+    assert group.region_shortname == "AR"
+    assert group.region_longname == "Arab"
+
+
 def test_serie_initialization(mock_xtream):
     series_info = {
         "series_id": 1,
@@ -136,6 +159,11 @@ def test_serie_initialization(mock_xtream):
     assert isinstance(serie.episodes, dict)
 
 
+def test_serie_export_json(mock_xtream):
+    serie = Serie(mock_xtream, {"series_id": 1, "name": "S1", "cover": "c", "last_modified": "1", "category_id": "1"})
+    assert "logo_path" in serie.export_json()
+
+
 def test_episode_initialization(mock_xtream):
     series_info = {"cover": f"{mock_provider_url}/cover.jpg"}
     episode_info = {
@@ -173,6 +201,7 @@ def test_validate_url(mock_xtream):
 
 def test_slugify(mock_xtream):
     assert mock_xtream._slugify("Test String!") == "test string!"
+    assert mock_xtream._slugify("movie_1.mp4") == "movie_1.mp4"
     assert mock_xtream._slugify("123ABC") == "123abc"
 
 
@@ -183,3 +212,102 @@ def test_get_logo_local_path(mock_xtream):
         "test provider-logo.png"
     )
     assert mock_xtream._get_logo_local_path(logo_url) == expected_path
+
+
+def test_load_iptv_full_flow(mock_xtream):
+    """Tests the complex load_iptv method which covers significant logic."""
+    mock_xtream.state["loaded"] = False  # Force reload
+
+    with patch.object(mock_xtream, '_load_from_file', return_value=None), \
+         patch.object(mock_xtream, '_get_request') as mock_req, \
+         patch.object(mock_xtream, '_save_to_file', return_value=True):
+
+        # Return sequence for: 
+        # 1. Live Categories, 2. Live Streams, 
+        # 3. VOD Categories, 4. VOD Streams, 
+        # 5. Series Categories, 6. Series Streams
+        mock_req.side_effect = [
+            MOCK_CATEGORIES, MOCK_STREAMS,
+            MOCK_CATEGORIES, MOCK_STREAMS,
+            MOCK_CATEGORIES, MOCK_SERIES
+        ]
+
+        success = mock_xtream.load_iptv()
+        assert success is True
+        assert len(mock_xtream.channels) > 0
+        assert len(mock_xtream.movies) > 0
+        assert len(mock_xtream.series) > 0
+
+
+def test_search_stream(mock_xtream):
+    # Assuming test_load_iptv_full_flow populated lists
+    results = mock_xtream.search_stream("Channel", return_type="LIST")
+    assert any(res["name"] == "Channel 1" for res in results)
+
+    json_results = mock_xtream.search_stream("Movie", return_type="JSON", stream_type=["movies"])
+    assert "Movie 1" in json_results
+
+
+def test_get_series_info_by_id(mock_xtream):
+    series_obj = Serie(mock_xtream, {"series_id": 1, "name": "Test", "cover": "c", "last_modified": "1"})
+    with patch.object(mock_xtream, '_get_request', return_value=MOCK_SERIES_INFO):
+        mock_xtream.get_series_info_by_id(series_obj)
+        assert "Season 1" in series_obj.seasons
+        assert len(series_obj.seasons["Season 1"].episodes) > 0
+
+
+def test_download_video(mock_xtream):
+    # Mock a movie in the collection
+    movie = Channel(mock_xtream, "VOD", MOCK_STREAMS[1])
+    mock_xtream.movies = [movie]
+
+    with patch.object(mock_xtream, '_download_video_impl', return_value=True):
+        path = mock_xtream.download_video("movie", 2)
+        assert "movie 1.mp4" in path
+
+
+def test_download_video_impl_resume(mock_xtream):
+    url = "http://test.com/video.ts"
+    filename = os.path.join(mock_xtream.cache_path, "test.ts")
+
+    # Mock existing file for resume
+    with patch('os.path.exists', return_value=True), \
+         patch('os.path.getsize', return_value=100), \
+         patch('requests.get') as mock_get, \
+         patch('builtins.open', mock_open()) as mocked_file:
+
+        mock_response = Mock()
+        mock_response.status_code = 206
+        mock_response.headers = {'content-type': 'video/mp2t', 'content-length': '500'}
+        mock_response.iter_content.return_value = [b'data']
+        mock_get.return_value = mock_response
+
+        res = mock_xtream._download_video_impl(url, filename)
+        assert res is True
+        # Verify that Range was passed to requests.get correctly
+        assert mock_get.call_args[1]['headers']['Range'] == 'bytes=100-'
+
+
+def test_get_request_progress(mock_xtream):
+    with patch('requests.get') as mock_get, \
+         patch('sys.stdout', new_callable=Mock):
+        mock_resp = Mock()
+        mock_resp.status_code = 200
+        mock_resp.iter_content.return_value = [b'{"key": "val"}']
+        mock_get.return_value = mock_resp
+
+        data = mock_xtream._get_request("http://api.url")
+        assert data == {"key": "val"}
+
+
+def test_epg_and_info_helpers(mock_xtream):
+    with patch.object(mock_xtream, '_get_request', return_value={"data": "test"}):
+        assert mock_xtream.vodInfoByID(1) == {"data": "test"}
+        assert mock_xtream.liveEpgByStream(1) == {"data": "test"}
+        assert mock_xtream.allEpg() == {"data": "test"}
+
+
+def test_get_last_7days(mock_xtream):
+    mock_xtream.movies_7days = [Channel(mock_xtream, "VOD", MOCK_STREAMS[1])]
+    res = json.loads(mock_xtream.get_last_7days())
+    assert len(res) == 1

From b6fcd36de906897d22baee7d2e086476e06ebc11 Mon Sep 17 00:00:00 2001
From: Claudio Olmi <superolmo2@gmail.com>
Date: Fri, 3 Apr 2026 20:44:27 -0500
Subject: [PATCH 4/4] Final changes

---
 README.md            | 1 +
 pyxtream/pyxtream.py | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 42cee64..546bf7d 100644
--- a/README.md
+++ b/README.md
@@ -107,6 +107,7 @@ Follows the Semantic Versioning from https://semver.org/
 
 | Date | Version | Description |
 | ----------- | -----| ----------- |
+| 2026-04-03 | 0.8.0 | - Added more PyTest functions<br>- Refactored index.html to better show cards<br>- Refactored pyxtream.py with types<br> - Removed cli progress bar<br>- Fixed issue with loading series [max298](https://github.com/max298)<br> - Fixed empty logo issue [max298](https://github.com/max298)
 | 2025-02-17 | 0.7.3 | - Added Initial PyTest and Coverage<br>- Added timestamp field "added" to Series to match channels "added" field<br>- Added string field "url" to Series to quickly get the series download address<br>- Added new API "get_last_7days()" returns the last added streams in the last 7 days in JSON format<br>- Added new API "get_download_progress()" returns information on the current download stream in JSON format<br>- Changed internal function _load_series_info_by_id_from_provider to allow returned value to change to JSON<br>- Changed search_stream function to only search in specific collections<br>- Refactored "rest_api.py" to make it easier to extend in the future<br>- Added new rest API<br>- Changed to Poetry environment<br>- Changed Functional Test to test loading series information<br>- Changed sample index.html to test more features|
 | 2024-09-02 | 0.7.2 | - Added missing request package to setup.py<br>- Refactored the search stream function and now, it can search for a specific stream type<br>- Refactored the download stream function<br>- Refactored the _get_request function and removed the call to the sleep function<br>- Added functional test to get series json output from a series_id<br>- Added functional test to get EPG for a specific stream ID<br>- Added xtream account expiration date printed on the console during authentication<br>- Improved results with the Flask HTML page and differentiating between movies and series<br>- Improved code readability|
 | 2024-05-21 | 0.7.1 | - Fixed missing jsonschema package<br>- Fixed provider name in functional_test<br>- Improved print out of connection attempts<br>- Added method to read latest changes in functional_test
diff --git a/pyxtream/pyxtream.py b/pyxtream/pyxtream.py
index 7d1afe2..c7ef3a3 100755
--- a/pyxtream/pyxtream.py
+++ b/pyxtream/pyxtream.py
@@ -600,7 +600,6 @@ def _download_video_impl(self, url: str, fullpath_filename: str) -> bool:
                         # Grab data by block_bytes
                         for data in response.iter_content(block_bytes, decode_unicode=False):
                             downloaded_bytes += block_bytes
-                            # progress(downloaded_bytes, total_content_size, "Downloading")
                             self.download_progress['Progress'] = downloaded_bytes
                             file.write(data)