From acf07012bb17bd36373ff03f4a7b236b9fa1990e Mon Sep 17 00:00:00 2001
From: g0ldyy <153996346+g0ldyy@users.noreply.github.com>
Date: Sat, 10 May 2025 18:07:41 +0200
Subject: [PATCH] oupsie

---
 CHANGELOG.md                               |  8 +++----
 README.md                                  |  8 +++----
 config/config.yml                          |  2 +-
 src/api/endpoints/download_api.rs          |  2 +-
 src/api/endpoints/v1_api.rs                |  2 +-
 src/api/endpoints/xtream_api.rs            |  8 +++----
 src/auth/authenticator.rs                  |  2 +-
 src/auth/password.rs                       |  2 +-
 src/foundation/filter.rs                   | 20 ++++++++--------
 src/m3u_filter_error.rs                    | 16 ++++++-------
 src/main.rs                                |  2 +-
 src/model/api_proxy.rs                     |  6 ++---
 src/model/config.rs                        | 24 +++++++++----------
 src/model/config_download.rs               |  4 ++--
 src/model/config_epg.rs                    |  4 ++--
 src/model/config_input.rs                  |  8 +++----
 src/model/config_ip_check.rs               |  2 +-
 src/model/config_proxy.rs                  |  2 +-
 src/model/config_rename.rs                 |  4 ++--
 src/model/config_sort.rs                   |  8 +++----
 src/model/config_source.rs                 |  4 ++--
 src/model/config_target.rs                 | 28 +++++++++++-----------
 src/model/config_web_auth.rs               |  6 ++---
 src/model/config_webui.rs                  |  2 +-
 src/model/hdhomerun_config.rs              |  6 ++---
 src/model/mapping.rs                       | 14 +++++------
 src/modules.rs                             |  2 +-
 src/processing/parser/xmltv.rs             |  2 +-
 src/processing/parser/xtream.rs            |  8 +++----
 src/processing/processor/playlist.rs       |  2 +-
 src/processing/processor/xtream.rs         |  4 ++--
 src/processing/processor/xtream_series.rs  |  4 ++--
 src/processing/processor/xtream_vod.rs     |  4 ++--
 src/repository/bplustree.rs                |  2 +-
 src/repository/epg_repository.rs           |  2 +-
 src/repository/indexed_document.rs         |  2 +-
 src/repository/kodi_repository.rs          |  6 ++---
 src/repository/m3u_playlist_iterator.rs    |  4 ++--
 src/repository/m3u_repository.rs           |  6 ++---
 src/repository/playlist_repository.rs      |  4 ++--
 src/repository/storage.rs                  |  4 ++--
 src/repository/xtream_playlist_iterator.rs |  4 ++--
 src/repository/xtream_repository.rs        |  6 ++---
 src/utils/bincode_utils.rs                 |  2 +-
 src/utils/crypto_utils.rs                  |  2 +-
 src/utils/file/config_reader.rs            | 10 ++++----
 src/utils/file/file_lock_manager.rs        |  2 +-
 src/utils/file/file_utils.rs               |  2 +-
 src/utils/network/epg.rs                   |  2 +-
 src/utils/network/ip_checker.rs            |  2 +-
 src/utils/network/m3u.rs                   |  2 +-
 src/utils/network/request.rs               | 22 ++++++++---------
 src/utils/network/xtream.rs                |  2 +-
 53 files changed, 154 insertions(+), 154 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 272e12926..3a8789c50 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,7 +16,7 @@ web_ui:
   path:
   auth:
     enabled: true
-    issuer: m3u_filter
+    issuer: tuliprox
     secret: ef9ab256a8c0abe5de92c2e05ca92baa810472ab702ff1674e9248308ceeec92
     userfile: user.txt
 ```
@@ -70,7 +70,7 @@ url: 'https://localhost.com/epg.xml'
 ```
 ```yaml
 # multi local file  epg
-url: ['file:///${env:M3U_FILTER_HOME}/epg.xml', 'file:///${env:M3U_FILTER_HOME}/epg2.xml']
+url: ['file:///${env:TULIPROX_HOME}/epg.xml', 'file:///${env:TULIPROX_HOME}/epg2.xml']
 ```
 ```yaml
 # multi url  epg
@@ -510,8 +510,8 @@ reverse_proxy:
    - `secret` secret for jwt token
    - `userfile` optional userfile with generated userfile in format "username: password" per file, default name is user.txt in config path
 * Password generation argument --genpwd  to generate passwords for userfile. 
-* Added env var `M3U_FILTER_LOG` for log level
-* Log Level has now module support like `m3u_filter::util=error,m3u_filter::filter=debug,m3u_filter=debug`
+* Added env var `TULIPROX_LOG` for log level
+* Log Level has now module support like `tuliprox::util=error,tuliprox::filter=debug,tuliprox=debug`
 * Multiple Xtream Sources merging into one target is now supported
 
 # v1.1.8(2024-03-06)
diff --git a/README.md b/README.md
index fa7efe473..03d88a802 100644
--- a/README.md
+++ b/README.md
@@ -268,7 +268,7 @@ if set to true, an update is started when the application starts.
 - `sanitize_sensitive_info` default true
 - `active_clients` default false, if set to true reverse proxy client count is printed as info log.
 - `log_level` can be set to `trace`, `debug`, `info`, `warn` and `error`.
-  You can also set module based level like `hyper_util::client::legacy::connect=error,m3u_filter=debug`
+  You can also set module based level like `hyper_util::client::legacy::connect=error,tuliprox=debug`
 
 
 `log_level` priority  CLI-Argument, Env-Var, Config, Default(`info`).
@@ -291,7 +291,7 @@ web_ui_enabled: true
 web_auth:
   enabled: true
   secret: very.secret.secret
-  issuer: m3u_filter
+  issuer: tuliprox
   userfile: user.txt
 ```
 
@@ -1297,12 +1297,12 @@ Following log levels are supported:
 
 Use the `-l` or `--log-level` cli-argument to specify the log-level.
 
-The log level can be set through environment variable `M3U_FILTER_LOG`,
+The log level can be set through environment variable `TULIPROX_LOG`,
 or config.
 
 Precedence is cli-argument, env-var, config, default(`info`).
 
-Log Level has module support like `m3u_filter::util=error,m3u_filter::filter=debug,m3u_filter=debug`
+Log Level has module support like `tuliprox::util=error,tuliprox::filter=debug,tuliprox=debug`
 
 ## 6. Web-UI
 
diff --git a/config/config.yml b/config/config.yml
index 93e81751e..4de11683e 100644
--- a/config/config.yml
+++ b/config/config.yml
@@ -33,7 +33,7 @@ web_ui:
   path:
   auth:
     enabled: true
-    issuer: m3u_filter
+    issuer: tuliprox
     secret: ef9ab256a8c0abe5de92c2e05ca92baa810472ab702ff1674e9248308ceeec92
     userfile: user.txt
 
diff --git a/src/api/endpoints/download_api.rs b/src/api/endpoints/download_api.rs
index c2af79e1b..af51d99a8 100644
--- a/src/api/endpoints/download_api.rs
+++ b/src/api/endpoints/download_api.rs
@@ -12,7 +12,7 @@ use std::ops::Deref;
 use std::sync::Arc;
 use std::{fs};
 use axum::response::IntoResponse;
-use crate::m3u_filter_error::to_io_error;
+use crate::tuliprox_error::to_io_error;
 use crate::utils::request::create_client;
 
 async fn download_file(active: Arc<RwLock<Option<FileDownload>>>, client: &reqwest::Client) -> Result<(), String> {
diff --git a/src/api/endpoints/v1_api.rs b/src/api/endpoints/v1_api.rs
index e3b2ec88b..5df4570bf 100644
--- a/src/api/endpoints/v1_api.rs
+++ b/src/api/endpoints/v1_api.rs
@@ -6,7 +6,7 @@ use crate::api::model::config::{ServerConfig, ServerInputConfig, ServerSourceCon
 use crate::api::model::request::{PlaylistRequest, PlaylistRequestType};
 use crate::auth::access_token::create_access_token;
 use crate::auth::authenticator::validator_admin;
-use crate::m3u_filter_error::M3uFilterError;
+use crate::tuliprox_error::M3uFilterError;
 use crate::model::StatusCheck;
 use crate::model::XtreamPlaylistItem;
 use crate::model::{validate_targets, Config, ConfigDto, ConfigInput, ConfigInputOptions, ConfigSource, ConfigTarget, InputType};
diff --git a/src/api/endpoints/xtream_api.rs b/src/api/endpoints/xtream_api.rs
index af58d54b7..c954b0a4d 100644
--- a/src/api/endpoints/xtream_api.rs
+++ b/src/api/endpoints/xtream_api.rs
@@ -10,9 +10,9 @@ use crate::api::model::request::UserApiRequest;
 use crate::api::model::streams::provider_stream::{create_custom_video_stream_response, CustomVideoStreamType}
 ;
 use crate::api::model::xtream::XtreamAuthorizationResponse;
-use crate::m3u_filter_error::create_m3u_filter_error_result;
-use crate::m3u_filter_error::info_err;
-use crate::m3u_filter_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::create_tuliprox_error_result;
+use crate::tuliprox_error::info_err;
+use crate::tuliprox_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
 use crate::model::{ProxyType, ProxyUserCredentials, UserConnectionPermission};
 use crate::model::TargetType;
 use crate::model::{Config, ConfigInput, ConfigTarget};
@@ -88,7 +88,7 @@ impl FromStr for XtreamApiStreamContext {
             Self::MOVIE => Ok(Self::Movie),
             Self::SERIES => Ok(Self::Series),
             Self::TIMESHIFT => Ok(Self::Timeshift),
-            _ => create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown CounterModifier: {}", s)
+            _ => create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown CounterModifier: {}", s)
         }
     }
 }
diff --git a/src/auth/authenticator.rs b/src/auth/authenticator.rs
index feb321ff5..f127e842d 100644
--- a/src/auth/authenticator.rs
+++ b/src/auth/authenticator.rs
@@ -5,7 +5,7 @@ use crate::api::api_utils::get_username_from_auth_header;
 use crate::model::WebAuthConfig;
 use crate::api::model::app_state::AppState;
 use crate::auth::auth_bearer::AuthBearer;
-use crate::m3u_filter_error::to_io_error;
+use crate::tuliprox_error::to_io_error;
 
 const ROLE_ADMIN: &str = "ADMIN";
 const ROLE_USER: &str = "USER";
diff --git a/src/auth/password.rs b/src/auth/password.rs
index f5b9e2d19..fea9a30be 100644
--- a/src/auth/password.rs
+++ b/src/auth/password.rs
@@ -1,6 +1,6 @@
 use rand::{Rng};
 use rand::distr::Alphanumeric;
-use crate::m3u_filter_error::str_to_io_error;
+use crate::tuliprox_error::str_to_io_error;
 
 fn generate_salt(length: usize) -> String {
     let salt: String = rand::rng()
diff --git a/src/foundation/filter.rs b/src/foundation/filter.rs
index 990cb035d..1753f4750 100644
--- a/src/foundation/filter.rs
+++ b/src/foundation/filter.rs
@@ -6,11 +6,11 @@ use log::{debug, error, log_enabled, trace, Level};
 use pest::iterators::Pair;
 use pest::Parser;
 
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::ItemField;
 use crate::model::{PlaylistItem, PlaylistItemType};
 use crate::tools::directed_graph::DirectedGraph;
-use crate::m3u_filter_error::{create_m3u_filter_error_result, info_err};
+use crate::tuliprox_error::{create_tuliprox_error_result, info_err};
 use crate::utils::CONSTANTS;
 use crate::utils::exit;
 
@@ -243,7 +243,7 @@ fn get_parser_item_field(expr: &Pair<Rule>) -> Result<ItemField, M3uFilterError>
             }
         }
     }
-    create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "unknown field: {}", expr.as_str())
+    create_tuliprox_error_result!(M3uFilterErrorKind::Info, "unknown field: {}", expr.as_str())
 }
 
 fn get_parser_regexp(
@@ -257,7 +257,7 @@ fn get_parser_regexp(
         let regstr = apply_templates_to_pattern(&parsed_text, templates);
         let re = regex::Regex::new(regstr.as_str());
         if re.is_err() {
-            return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {}", regstr);
+            return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {}", regstr);
         }
         let regexp = re.unwrap();
         let captures = regexp
@@ -275,7 +275,7 @@ fn get_parser_regexp(
             captures,
         });
     }
-    create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "unknown field: {}", expr.as_str())
+    create_tuliprox_error_result!(M3uFilterErrorKind::Info, "unknown field: {}", expr.as_str())
 }
 
 fn get_parser_field_comparison(
@@ -315,7 +315,7 @@ fn get_parser_type_comparison(expr: Pair<Rule>) -> Result<Filter, M3uFilterError
     let expr_inner = expr.into_inner();
     let text_item_type = expr_inner.as_str();
     let item_type = get_filter_item_type(text_item_type);
-    item_type.map_or_else(|| create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse item type: {text_item_type}"), |itype| Ok(Filter::TypeComparison(ItemField::Type, itype)))
+    item_type.map_or_else(|| create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse item type: {text_item_type}"), |itype| Ok(Filter::TypeComparison(ItemField::Type, itype)))
 }
 
 macro_rules! handle_expr {
@@ -400,7 +400,7 @@ fn get_parser_binary_op(expr: &Pair<Rule>) -> Result<BinaryOperator, M3uFilterEr
     match expr.as_rule() {
         Rule::and => Ok(BinaryOperator::And),
         Rule::or => Ok(BinaryOperator::Or),
-        _ => create_m3u_filter_error_result!(
+        _ => create_tuliprox_error_result!(
             M3uFilterErrorKind::Info,
             "Unknown binary operator {}",
             expr.as_str()
@@ -471,7 +471,7 @@ pub fn get_filter(
 
             result.map_or_else(
                 || {
-                    create_m3u_filter_error_result!(
+                    create_tuliprox_error_result!(
                         M3uFilterErrorKind::Info,
                         "Unable to parse filter: {}",
                         &filter_text
@@ -480,7 +480,7 @@ pub fn get_filter(
                 Ok,
             )
         }
-        Err(err) => create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "{}", err),
+        Err(err) => create_tuliprox_error_result!(M3uFilterErrorKind::Info, "{}", err),
     }
 }
 
@@ -508,7 +508,7 @@ fn build_dependency_graph(
         );
     }
     if !cycles.is_empty() {
-        return create_m3u_filter_error_result!(
+        return create_tuliprox_error_result!(
             M3uFilterErrorKind::Info,
             "Cyclic dependencies in templates detected!"
         );
diff --git a/src/m3u_filter_error.rs b/src/m3u_filter_error.rs
index 58cdb9296..ce7c57857 100644
--- a/src/m3u_filter_error.rs
+++ b/src/m3u_filter_error.rs
@@ -43,23 +43,23 @@ pub use info_err;
 
 
 #[macro_export]
-macro_rules! create_m3u_filter_error {
+macro_rules! create_tuliprox_error {
      ($kind: expr, $($arg:tt)*) => {
         M3uFilterError::new($kind, format!($($arg)*))
     }
 }
-pub use create_m3u_filter_error;
+pub use create_tuliprox_error;
 
 #[macro_export]
-macro_rules! create_m3u_filter_error_result {
+macro_rules! create_tuliprox_error_result {
      ($kind: expr, $($arg:tt)*) => {
         Err(M3uFilterError::new($kind, format!($($arg)*)))
     }
 }
-pub use create_m3u_filter_error_result;
+pub use create_tuliprox_error_result;
 
 #[macro_export]
-macro_rules! handle_m3u_filter_error_result_list {
+macro_rules! handle_tuliprox_error_result_list {
     ($kind:expr, $result: expr) => {
         let errors = $result
             .filter_map(|result| {
@@ -76,10 +76,10 @@ macro_rules! handle_m3u_filter_error_result_list {
     }
 }
 
-pub use handle_m3u_filter_error_result_list;
+pub use handle_tuliprox_error_result_list;
 
 #[macro_export]
-macro_rules! handle_m3u_filter_error_result {
+macro_rules! handle_tuliprox_error_result {
     ($kind:expr, $result: expr) => {
         if let Err(err) = $result {
             return Err(M3uFilterError::new($kind, err.to_string()));
@@ -87,7 +87,7 @@ macro_rules! handle_m3u_filter_error_result {
     }
 }
 
-pub use handle_m3u_filter_error_result;
+pub use handle_tuliprox_error_result;
 
 
 #[derive(Debug, PartialEq, Eq)]
diff --git a/src/main.rs b/src/main.rs
index f591c8251..7bd4e1715 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -103,7 +103,7 @@ fn main() {
     let config_path: String = args.config_path.unwrap_or_else(file_utils::get_default_config_path);
     let config_file: String = args.config_file.unwrap_or_else(|| file_utils::get_default_config_file_path(&config_path));
 
-    let env_log_level = std::env::var("M3U_FILTER_LOG");
+    let env_log_level = std::env::var("TULIPROX_LOG");
     init_logger(args.log_level.as_ref(), env_log_level.ok(), config_file.as_str());
 
     if args.healthcheck {
diff --git a/src/model/api_proxy.rs b/src/model/api_proxy.rs
index f69a52336..6012c5e3f 100644
--- a/src/model/api_proxy.rs
+++ b/src/model/api_proxy.rs
@@ -1,5 +1,5 @@
 use crate::api::model::app_state::AppState;
-use crate::m3u_filter_error::{create_m3u_filter_error_result, info_err, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{create_tuliprox_error_result, info_err, M3uFilterError, M3uFilterErrorKind};
 use crate::model::{Config, ClusterFlags};
 use crate::repository::user_repository::{backup_api_user_db_file, get_api_user_db_path, load_api_user, merge_api_user};
 use crate::utils::default_as_true;
@@ -95,7 +95,7 @@ impl FromStr for ProxyType {
             }
         }
 
-        create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown ProxyType: {}", s)
+        create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown ProxyType: {}", s)
     }
 }
 
@@ -179,7 +179,7 @@ impl FromStr for ProxyUserStatus {
             Self::TRIAL => Ok(Self::Trial),
             Self::DISABLED => Ok(Self::Disabled),
             Self::PENDING => Ok(Self::Pending),
-            _ => create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown ProxyType: {}", s)
+            _ => create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown ProxyType: {}", s)
         }
     }
 }
diff --git a/src/model/config.rs b/src/model/config.rs
index a8afae851..ae1499ef1 100644
--- a/src/model/config.rs
+++ b/src/model/config.rs
@@ -11,14 +11,14 @@ use path_clean::PathClean;
 use rand::Rng;
 
 use crate::foundation::filter::{prepare_templates,  PatternTemplate};
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::{ApiProxyConfig, ApiProxyServerInfo, ProxyUserCredentials, Mappings};
 use crate::utils::{default_as_default, default_connect_timeout_secs, default_grace_period_millis, default_grace_period_timeout_secs};
 use crate::utils::file_lock_manager::FileLockManager;
 use crate::utils::file_utils;
 use crate::utils::{parse_size_base_2, parse_to_kbps};
 use crate::utils::exit;
-use crate::m3u_filter_error::{ create_m3u_filter_error_result};
+use crate::tuliprox_error::{ create_tuliprox_error_result};
 use crate::model::{ConfigInput, ConfigInputOptions, IpCheckConfig, ProxyConfig, ConfigSource, ConfigTarget, HdHomeRunConfig, LogConfig, MessagingConfig, ProcessTargets, TargetOutput, VideoConfig, WebUiConfig};
 
 const STREAM_QUEUE_SIZE: usize = 1024; // mpsc channel holding messages. with 8192byte chunks and 2Mbit/s approx 8MB
@@ -407,10 +407,10 @@ impl Config {
         if let Some(username) = output_username {
             if let Some((_, config_target)) = self.get_target_for_username(username).await {
                 if config_target.name != target_name {
-                    return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "User:{username} does not belong to target: {}", target_name);
+                    return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "User:{username} does not belong to target: {}", target_name);
                 }
             } else {
-                return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "User: {username} does not exist");
+                return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "User: {username} does not exist");
             }
             Ok(())
         } else {
@@ -572,20 +572,20 @@ impl Config {
             for input in &source.inputs {
                 let input_name = input.name.trim().to_string();
                 if input_name.is_empty() {
-                    return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "input name required");
+                    return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "input name required");
                 }
                 if seen_names.contains(input_name.as_str()) {
-                    return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "input names should be unique: {}", input_name);
+                    return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "input names should be unique: {}", input_name);
                 }
                 seen_names.insert(input_name);
                 if let Some(aliases) = &input.aliases {
                     for alias in aliases {
                         let input_name = alias.name.trim().to_string();
                         if input_name.is_empty() {
-                            return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "input name required");
+                            return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "input name required");
                         }
                         if seen_names.contains(input_name.as_str()) {
-                            return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "input names should be unique: {}", input_name);
+                            return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "input names should be unique: {}", input_name);
                         }
                         seen_names.insert(input_name);
                     }
@@ -603,11 +603,11 @@ impl Config {
                 // check target name is unique
                 let target_name = target.name.trim().to_string();
                 if target_name.is_empty() {
-                    return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "target name required");
+                    return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "target name required");
                 }
                 if !default_target_name.eq_ignore_ascii_case(target_name.as_str()) {
                     if seen_names.contains(target_name.as_str()) {
-                        return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "target names should be unique: {}", target_name);
+                        return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "target names should be unique: {}", target_name);
                     }
                     seen_names.insert(target_name);
                 }
@@ -622,7 +622,7 @@ impl Config {
                 if let Some(targets) = &schedule.targets {
                     for target_name in targets {
                         if !target_names.contains(target_name) {
-                            return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown target name in scheduler: {}", target_name);
+                            return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown target name in scheduler: {}", target_name);
                         }
                     }
                 }
@@ -820,7 +820,7 @@ pub fn validate_targets(target_args: Option<&Vec<String>>, sources: &Vec<ConfigS
 
         let missing_targets: Vec<String> = check_targets.iter().filter(|&(_, v)| *v == 0).map(|(k, _)| k.to_string()).collect();
         if !missing_targets.is_empty() {
-            return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "No target found for {}", missing_targets.join(", "));
+            return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "No target found for {}", missing_targets.join(", "));
         }
         // let processing_targets: Vec<String> = check_targets.iter().filter(|&(_, v)| *v != 0).map(|(k, _)| k.to_string()).collect();
         // info!("Processing targets {}", processing_targets.join(", "));
diff --git a/src/model/config_download.rs b/src/model/config_download.rs
index 486f22498..e901f4613 100644
--- a/src/model/config_download.rs
+++ b/src/model/config_download.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{create_m3u_filter_error_result, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{create_tuliprox_error_result, M3uFilterError, M3uFilterErrorKind};
 use regex::Regex;
 use std::borrow::BorrowMut;
 use std::collections::HashMap;
@@ -57,7 +57,7 @@ impl VideoConfig {
                                 downl.t_re_episode_pattern = Some(pattern);
                             }
                             Err(err) => {
-                                return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {episode_pattern} {err}");
+                                return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {episode_pattern} {err}");
                             }
                         }
                     }
diff --git a/src/model/config_epg.rs b/src/model/config_epg.rs
index 8af5e2921..19ce5cd55 100644
--- a/src/model/config_epg.rs
+++ b/src/model/config_epg.rs
@@ -1,6 +1,6 @@
 use log::warn;
 use regex::Regex;
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error_result};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, create_tuliprox_error_result};
 use crate::utils::CONSTANTS;
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -99,7 +99,7 @@ impl EpgSmartMatchConfig {
             Some(regstr) => {
                 let re = regex::Regex::new(regstr.as_str());
                 if re.is_err() {
-                    return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {}", regstr);
+                    return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {}", regstr);
                 }
                 Some(re.unwrap())
             }
diff --git a/src/model/config_input.rs b/src/model/config_input.rs
index 9a33a1aa6..538a12811 100644
--- a/src/model/config_input.rs
+++ b/src/model/config_input.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{create_m3u_filter_error_result, handle_m3u_filter_error_result_list, info_err, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{create_tuliprox_error_result, handle_tuliprox_error_result_list, info_err, M3uFilterError, M3uFilterErrorKind};
 use crate::model::EpgConfig;
 use crate::utils::config_reader::csv_read_inputs;
 use crate::utils::default_as_true;
@@ -94,7 +94,7 @@ impl FromStr for InputType {
         } else if s.eq(Self::XTREAM_BATCH) {
             Ok(Self::XtreamBatch)
         } else {
-            create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown InputType: {}", s)
+            create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown InputType: {}", s)
         }
     }
 }
@@ -139,7 +139,7 @@ impl FromStr for InputFetchMethod {
         } else if s.eq(Self::POST_METHOD) {
             Ok(Self::POST)
         } else {
-            create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown Fetch Method: {}", s)
+            create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown Fetch Method: {}", s)
         }
     }
 }
@@ -318,7 +318,7 @@ impl ConfigInput {
 
         if let Some(aliases) = self.aliases.as_mut() {
             let input_type = &self.input_type;
-            handle_m3u_filter_error_result_list!(M3uFilterErrorKind::Info, aliases.iter_mut().enumerate().map(|(idx, i)| i.prepare(index+1+(idx as u16), input_type)));
+            handle_tuliprox_error_result_list!(M3uFilterErrorKind::Info, aliases.iter_mut().enumerate().map(|(idx, i)| i.prepare(index+1+(idx as u16), input_type)));
         }
         Ok(index + self.aliases.as_ref().map_or(0, std::vec::Vec::len) as u16)
     }
diff --git a/src/model/config_ip_check.rs b/src/model/config_ip_check.rs
index 7a5b73271..29f69378c 100644
--- a/src/model/config_ip_check.rs
+++ b/src/model/config_ip_check.rs
@@ -1,5 +1,5 @@
 use regex::Regex;
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Default)]
 #[serde(deny_unknown_fields)]
diff --git a/src/model/config_proxy.rs b/src/model/config_proxy.rs
index c089dbfd6..c10a4afb3 100644
--- a/src/model/config_proxy.rs
+++ b/src/model/config_proxy.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Default)]
 #[serde(deny_unknown_fields)]
diff --git a/src/model/config_rename.rs b/src/model/config_rename.rs
index b2bbf39f0..efe1fb322 100644
--- a/src/model/config_rename.rs
+++ b/src/model/config_rename.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error_result};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, create_tuliprox_error_result};
 use crate::model::ItemField;
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -18,7 +18,7 @@ impl ConfigRename {
                 self.re = Some(pattern);
                 Ok(())
             }
-            Err(err) => create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {} {err}", &self.pattern),
+            Err(err) => create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {} {err}", &self.pattern),
         }
     }
 }
\ No newline at end of file
diff --git a/src/model/config_sort.rs b/src/model/config_sort.rs
index 58485473e..04b1b643c 100644
--- a/src/model/config_sort.rs
+++ b/src/model/config_sort.rs
@@ -1,5 +1,5 @@
 use regex::Regex;
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error, handle_m3u_filter_error_result_list};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, create_tuliprox_error, handle_tuliprox_error_result_list};
 use crate::model::{ItemField};
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -15,7 +15,7 @@ fn compile_regex_vec(patterns: Option<&Vec<String>>) -> Result<Option<Vec<Regex>
         .map(|seq| {
             seq.iter()
                 .map(|s| Regex::new(s).map_err(|err| {
-                    create_m3u_filter_error!(M3uFilterErrorKind::Info, "cant parse regex: {s} {err}")
+                    create_tuliprox_error!(M3uFilterErrorKind::Info, "cant parse regex: {s} {err}")
                 }))
                 .collect::<Result<Vec<_>, _>>()
         })
@@ -62,7 +62,7 @@ impl ConfigSortChannel {
         // Compile group_pattern
         self.t_re_group_pattern = Some(
             Regex::new(&self.group_pattern).map_err(|err| {
-                create_m3u_filter_error!(M3uFilterErrorKind::Info, "cant parse regex: {} {err}", &self.group_pattern)
+                create_tuliprox_error!(M3uFilterErrorKind::Info, "cant parse regex: {} {err}", &self.group_pattern)
             })?
         );
 
@@ -89,7 +89,7 @@ impl ConfigSort {
             group.prepare()?;
         }
         if let Some(channels) = self.channels.as_mut() {
-            handle_m3u_filter_error_result_list!(M3uFilterErrorKind::Info, channels.iter_mut().map(ConfigSortChannel::prepare));
+            handle_tuliprox_error_result_list!(M3uFilterErrorKind::Info, channels.iter_mut().map(ConfigSortChannel::prepare));
         }
         Ok(())
     }
diff --git a/src/model/config_source.rs b/src/model/config_source.rs
index 6d065f350..68e1a87b7 100644
--- a/src/model/config_source.rs
+++ b/src/model/config_source.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, handle_m3u_filter_error_result_list};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, handle_tuliprox_error_result_list};
 use crate::model::ConfigInput;
 use crate::model::config_target::ConfigTarget;
 
@@ -12,7 +12,7 @@ pub struct ConfigSource {
 impl ConfigSource {
     #[allow(clippy::cast_possible_truncation)]
     pub fn prepare(&mut self, index: u16, include_computed: bool) -> Result<u16, M3uFilterError> {
-        handle_m3u_filter_error_result_list!(M3uFilterErrorKind::Info, self.inputs.iter_mut().enumerate().map(|(idx, i)| i.prepare(index+(idx as u16), include_computed)));
+        handle_tuliprox_error_result_list!(M3uFilterErrorKind::Info, self.inputs.iter_mut().enumerate().map(|(idx, i)| i.prepare(index+(idx as u16), include_computed)));
         Ok(index + (self.inputs.len() as u16))
     }
 
diff --git a/src/model/config_target.rs b/src/model/config_target.rs
index 8e36b84d8..4d818a5c6 100644
--- a/src/model/config_target.rs
+++ b/src/model/config_target.rs
@@ -1,5 +1,5 @@
 use crate::foundation::filter::{get_filter, Filter, MockValueProcessor, PatternTemplate, ValueProvider};
-use crate::m3u_filter_error::{create_m3u_filter_error_result, handle_m3u_filter_error_result, handle_m3u_filter_error_result_list, info_err, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{create_tuliprox_error_result, handle_tuliprox_error_result, handle_tuliprox_error_result_list, info_err, M3uFilterError, M3uFilterErrorKind};
 use crate::model::cluster_flags::ClusterFlags;
 use crate::model::config_rename::ConfigRename;
 use crate::model::config_sort::ConfigSort;
@@ -208,7 +208,7 @@ impl ConfigTarget {
                 TargetOutput::Xtream(_) => {
                     xtream_cnt += 1;
                     if default_as_default().eq_ignore_ascii_case(&self.name) {
-                        return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "unique target name is required for xtream type output: {}", self.name);
+                        return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "unique target name is required for xtream type output: {}", self.name);
                     }
                 }
                 TargetOutput::M3u(m3u_output) => {
@@ -219,7 +219,7 @@ impl ConfigTarget {
                     strm_cnt += 1;
                     strm_output.directory = strm_output.directory.trim().to_string();
                     if strm_output.directory.trim().is_empty() {
-                        return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "directory is required for strm type: {}", self.name);
+                        return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "directory is required for strm type: {}", self.name);
                     }
                     if let Some(username) = &mut strm_output.username {
                         *username = username.trim().to_string();
@@ -234,19 +234,19 @@ impl ConfigTarget {
                     hdhr_cnt += 1;
                     hdhomerun_output.username = hdhomerun_output.username.trim().to_string();
                     if hdhomerun_output.username.is_empty() {
-                        return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Username is required for HdHomeRun type: {}", self.name);
+                        return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Username is required for HdHomeRun type: {}", self.name);
                     }
 
                     hdhomerun_output.device = hdhomerun_output.device.trim().to_string();
                     if hdhomerun_output.device.is_empty() {
-                        return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Device is required for HdHomeRun type: {}", self.name);
+                        return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Device is required for HdHomeRun type: {}", self.name);
                     }
 
                     if let Some(use_output) = hdhomerun_output.use_output.as_ref() {
                         match &use_output {
                             TargetType::M3u => { hdhomerun_needs_m3u = true; }
                             TargetType::Xtream => { hdhomerun_needs_xtream = true; }
-                            _ => return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output option `use_output` only accepts `m3u` or `xtream` for target: {}", self.name),
+                            _ => return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output option `use_output` only accepts `m3u` or `xtream` for target: {}", self.name),
                         }
                     }
                 }
@@ -254,22 +254,22 @@ impl ConfigTarget {
         }
 
         if m3u_cnt > 1 || strm_cnt > 1 || xtream_cnt > 1 || hdhr_cnt > 1 {
-            return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Multiple output formats with same type : {}", self.name);
+            return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Multiple output formats with same type : {}", self.name);
         }
 
         if strm_cnt > 0 && strm_needs_xtream && xtream_cnt == 0 {
-            return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "strm output with a username is only permitted when used in combination with xtream output: {}", self.name);
+            return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "strm output with a username is only permitted when used in combination with xtream output: {}", self.name);
         }
 
         if hdhr_cnt > 0 {
             if xtream_cnt == 0 && m3u_cnt == 0 {
-                return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output is only permitted when used in combination with xtream or m3u output: {}", self.name);
+                return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output is only permitted when used in combination with xtream or m3u output: {}", self.name);
             }
             if hdhomerun_needs_m3u && m3u_cnt == 0 {
-                return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output has `use_output=m3u` but no `m3u` output defined: {}", self.name);
+                return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output has `use_output=m3u` but no `m3u` output defined: {}", self.name);
             }
             if hdhomerun_needs_xtream && xtream_cnt == 0 {
-                return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output has `use_output=xtream` but no `xtream` output defined: {}", self.name);
+                return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output has `use_output=xtream` but no `xtream` output defined: {}", self.name);
             }
         }
 
@@ -278,7 +278,7 @@ impl ConfigTarget {
             match regexps {
                 Ok(watch_re) => self.t_watch_re = Some(watch_re),
                 Err(err) => {
-                    return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Invalid watch regular expression: {}", err);
+                    return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Invalid watch regular expression: {}", err);
                 }
             }
         }
@@ -288,10 +288,10 @@ impl ConfigTarget {
                 // debug!("Filter: {}", fltr);
                 self.t_filter = Some(fltr);
                 if let Some(renames) = self.rename.as_mut() {
-                    handle_m3u_filter_error_result_list!(M3uFilterErrorKind::Info, renames.iter_mut().map(ConfigRename::prepare));
+                    handle_tuliprox_error_result_list!(M3uFilterErrorKind::Info, renames.iter_mut().map(ConfigRename::prepare));
                 }
                 if let Some(sort) = self.sort.as_mut() {
-                    handle_m3u_filter_error_result!(M3uFilterErrorKind::Info, sort.prepare());
+                    handle_tuliprox_error_result!(M3uFilterErrorKind::Info, sort.prepare());
                 }
                 Ok(())
             }
diff --git a/src/model/config_web_auth.rs b/src/model/config_web_auth.rs
index 54c0b4e4a..a80ff1d14 100644
--- a/src/model/config_web_auth.rs
+++ b/src/model/config_web_auth.rs
@@ -3,7 +3,7 @@ use std::fs::File;
 use std::io::BufRead;
 use std::path::PathBuf;
 use crate::auth::user::UserCredential;
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error_result};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, create_tuliprox_error_result};
 use crate::utils::file_utils;
 use crate::utils::file_utils::file_reader;
 
@@ -29,7 +29,7 @@ impl WebAuthConfig {
         if !file_utils::path_exists(&userfile_path) {
             userfile_path = PathBuf::from(config_path).join(&userfile_name);
             if !file_utils::path_exists(&userfile_path) {
-                return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Could not find userfile {}", &userfile_name);
+                return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Could not find userfile {}", &userfile_name);
             }
         }
 
@@ -50,7 +50,7 @@ impl WebAuthConfig {
 
             self.t_users = Some(users);
         } else {
-            return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Could not read userfile {:?}", &userfile_path);
+            return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Could not read userfile {:?}", &userfile_path);
         }
         Ok(())
     }
diff --git a/src/model/config_webui.rs b/src/model/config_webui.rs
index dd76549f2..c397b976e 100644
--- a/src/model/config_webui.rs
+++ b/src/model/config_webui.rs
@@ -1,5 +1,5 @@
 use crate::utils::default_as_true;
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::WebAuthConfig;
 
 const RESERVED_PATHS: &[&str] = &[
diff --git a/src/model/hdhomerun_config.rs b/src/model/hdhomerun_config.rs
index fc397b916..c6da24217 100644
--- a/src/model/hdhomerun_config.rs
+++ b/src/model/hdhomerun_config.rs
@@ -1,6 +1,6 @@
 use std::collections::HashSet;
 use log::warn;
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error_result};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, create_tuliprox_error_result};
 fn default_friendly_name() -> String { String::from("M3uFilterTV") }
 fn default_manufacturer() -> String { String::from("Silicondust") }
 fn default_model_name() -> String { String::from("HDTC-2US") }
@@ -80,11 +80,11 @@ impl HdHomeRunConfig {
             device.prepare(device_num);
             if names.contains(&device.name) {
                 names.insert(&device.name);
-                return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun duplicate device name {}", device.name);
+                return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun duplicate device name {}", device.name);
             }
             if device.port > 0 && ports.contains(&device.port) {
                 ports.insert(device.port);
-                return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun duplicate port {}", device.port);
+                return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun duplicate port {}", device.port);
             }
         }
         let mut current_port = api_port + 1;
diff --git a/src/model/mapping.rs b/src/model/mapping.rs
index 5916953ad..96310e3b8 100644
--- a/src/model/mapping.rs
+++ b/src/model/mapping.rs
@@ -9,8 +9,8 @@ use std::sync::atomic::AtomicU32;
 use std::sync::Arc;
 
 use crate::foundation::filter::{apply_templates_to_pattern, get_filter, prepare_templates, Filter, PatternTemplate, RegexWithCaptures, ValueProcessor};
-use crate::m3u_filter_error::{create_m3u_filter_error_result, handle_m3u_filter_error_result, info_err};
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{create_tuliprox_error_result, handle_tuliprox_error_result, info_err};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::valid_property;
 use crate::model::{ItemField};
 use crate::model::{FieldGetAccessor, FieldSetAccessor, PlaylistItem};
@@ -84,7 +84,7 @@ impl FromStr for CounterModifier {
         } else if s.eq("prefix") {
             Ok(Self::Prefix)
         } else {
-            create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown CounterModifier: {}", s)
+            create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown CounterModifier: {}", s)
         }
     }
 }
@@ -156,7 +156,7 @@ impl FromStr for TransformModifier {
         } else if s.eq("capitalize") {
             Ok(Self::Capitalize)
         } else {
-            create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown TransformModifier: {}", s)
+            create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown TransformModifier: {}", s)
         }
     }
 }
@@ -184,7 +184,7 @@ impl MapperTransform {
                 }
                 match Regex::new(&new_pattern) {
                     Ok(pattern) => self.t_pattern = Some(pattern),
-                    Err(err) => return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {new_pattern} {err}"),
+                    Err(err) => return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {new_pattern} {err}"),
                 }
             }
         }
@@ -455,7 +455,7 @@ impl Mapping {
     pub fn prepare(&mut self, templates: Option<&Vec<PatternTemplate>>,
                    tags: Option<&Vec<MappingTag>>) -> Result<(), M3uFilterError> {
         for mapper in &mut self.mapper {
-            handle_m3u_filter_error_result!(M3uFilterErrorKind::Info, mapper.prepare(templates, tags));
+            handle_tuliprox_error_result!(M3uFilterErrorKind::Info, mapper.prepare(templates, tags));
         }
 
         if let Some(counter_def_list) = &self.counter {
@@ -505,7 +505,7 @@ impl MappingDefinition {
         for mapping in &mut self.mapping {
             let template_list = self.templates.as_ref();
             let tag_list = self.tags.as_ref();
-            handle_m3u_filter_error_result!(M3uFilterErrorKind::Info, mapping.prepare(template_list, tag_list));
+            handle_tuliprox_error_result!(M3uFilterErrorKind::Info, mapping.prepare(template_list, tag_list));
         }
         Ok(())
     }
diff --git a/src/modules.rs b/src/modules.rs
index 2017f20e5..279a067fd 100644
--- a/src/modules.rs
+++ b/src/modules.rs
@@ -8,7 +8,7 @@ macro_rules! include_modules {
         extern crate pest_derive;
         pub mod api;
         pub mod auth;
-        pub mod m3u_filter_error;
+        pub mod tuliprox_error;
         pub mod messaging;
         pub mod model;
         pub mod processing;
diff --git a/src/processing/parser/xmltv.rs b/src/processing/parser/xmltv.rs
index d90c7373c..0f07b77a4 100644
--- a/src/processing/parser/xmltv.rs
+++ b/src/processing/parser/xmltv.rs
@@ -500,7 +500,7 @@ mod tests {
         assert_eq!("odisea.bg", normalize_channel_name("BG | ODISEA ᵁᴴᴰ ³⁸⁴⁰ᴾ", &epg_smart_cfg));
     }
 
-    use crate::m3u_filter_error::M3uFilterError;
+    use crate::tuliprox_error::M3uFilterError;
     use rphonetic::{Encoder, Metaphone};
 
     #[test]
diff --git a/src/processing/parser/xtream.rs b/src/processing/parser/xtream.rs
index bd3bf9451..4a22a0029 100644
--- a/src/processing/parser/xtream.rs
+++ b/src/processing/parser/xtream.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{create_m3u_filter_error_result, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{create_tuliprox_error_result, M3uFilterError, M3uFilterErrorKind};
 use crate::model::ConfigInput;
 use crate::model::{PlaylistGroup, PlaylistItem, PlaylistItemHeader, PlaylistItemType, XtreamCluster};
 use crate::model::{XtreamCategory, XtreamSeriesInfo, XtreamSeriesInfoEpisode, XtreamStream};
@@ -12,7 +12,7 @@ fn map_to_xtream_category(categories: &Value) -> Result<Vec<XtreamCategory>, M3u
     match serde_json::from_value::<Vec<XtreamCategory>>(categories.to_owned()) {
         Ok(xtream_categories) => Ok(xtream_categories),
         Err(err) => {
-            create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to process categories {}", &err)
+            create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to process categories {}", &err)
         }
     }
 }
@@ -21,7 +21,7 @@ fn map_to_xtream_streams(xtream_cluster: XtreamCluster, streams: &Value) -> Resu
     match serde_json::from_value::<Vec<XtreamStream>>(streams.to_owned()) {
         Ok(stream_list) => Ok(stream_list),
         Err(err) => {
-            create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to map to xtream streams {:?}: {}", xtream_cluster, &err)
+            create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to map to xtream streams {:?}: {}", xtream_cluster, &err)
         }
     }
 }
@@ -70,7 +70,7 @@ pub fn parse_xtream_series_info(info: &Value, group_title: &str, series_name: &s
             Ok(None)
         }
         Err(err) => {
-            create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to process series info for {series_name} {err}")
+            create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to process series info for {series_name} {err}")
         }
     }
 }
diff --git a/src/processing/processor/playlist.rs b/src/processing/processor/playlist.rs
index bf34cd814..d9473d099 100644
--- a/src/processing/processor/playlist.rs
+++ b/src/processing/processor/playlist.rs
@@ -10,7 +10,7 @@ use std::thread;
 use tokio::sync::Mutex;
 
 use crate::foundation::filter::{get_field_value, set_field_value, MockValueProcessor, ValueProvider};
-use crate::m3u_filter_error::{get_errors_notify_message, notify_err, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{get_errors_notify_message, notify_err, M3uFilterError, M3uFilterErrorKind};
 use crate::messaging::{send_message, MsgKind};
 use crate::model::{ConfigTarget, InputType, ItemField, ProcessTargets, ProcessingOrder};
 use crate::model::{CounterModifier, Mapping, MappingValueProcessor};
diff --git a/src/processing/processor/xtream.rs b/src/processing/processor/xtream.rs
index be680a9cb..0513c45b3 100644
--- a/src/processing/processor/xtream.rs
+++ b/src/processing/processor/xtream.rs
@@ -1,5 +1,5 @@
-use crate::m3u_filter_error::{info_err, notify_err};
-use crate::m3u_filter_error::{str_to_io_error, to_io_error, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{info_err, notify_err};
+use crate::tuliprox_error::{str_to_io_error, to_io_error, M3uFilterError, M3uFilterErrorKind};
 use crate::model::{Config, ConfigInput};
 use crate::model::{FetchedPlaylist, PlaylistEntry, PlaylistItem, PlaylistItemType, XtreamCluster};
 use crate::repository::storage::get_input_storage_path;
diff --git a/src/processing/processor/xtream_series.rs b/src/processing/processor/xtream_series.rs
index c2c6f0cdb..da36c9aba 100644
--- a/src/processing/processor/xtream_series.rs
+++ b/src/processing/processor/xtream_series.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::{Config, ConfigTarget, InputType};
 use crate::model::{FetchedPlaylist, PlaylistGroup, PlaylistItem, PlaylistItemType, XtreamCluster};
 use crate::processing::processor::playlist::ProcessingPipe;
@@ -7,7 +7,7 @@ use crate::processing::processor::xtream::{create_resolve_episode_wal_files, cre
 use crate::repository::storage::get_input_storage_path;
 use crate::repository::xtream_repository::{xtream_get_info_file_paths, xtream_update_input_info_file, xtream_update_input_series_episodes_record_from_wal_file, xtream_update_input_series_record_from_wal_file};
 use crate::repository::IndexedDocumentReader;
-use crate::m3u_filter_error::{notify_err, info_err};
+use crate::tuliprox_error::{notify_err, info_err};
 use crate::processing::processor::{handle_error, handle_error_and_return, create_resolve_options_function_for_xtream_target};
 use std::collections::HashMap;
 use std::fs::File;
diff --git a/src/processing/processor/xtream_vod.rs b/src/processing/processor/xtream_vod.rs
index 5ebc7daba..b904f0dec 100644
--- a/src/processing/processor/xtream_vod.rs
+++ b/src/processing/processor/xtream_vod.rs
@@ -1,9 +1,9 @@
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::{Config, ConfigTarget, InputType};
 use crate::model::{FetchedPlaylist, PlaylistItem, PlaylistItemType, XtreamCluster};
 use crate::processing::processor::xtream::{create_resolve_info_wal_files, playlist_resolve_download_playlist_item, read_processed_info_ids, should_update_info, write_info_content_to_wal_file};
 use crate::repository::xtream_repository::{xtream_update_input_info_file, xtream_update_input_vod_record_from_wal_file, InputVodInfoRecord};
-use crate::m3u_filter_error::{notify_err};
+use crate::tuliprox_error::{notify_err};
 use crate::processing::processor::{handle_error, handle_error_and_return, create_resolve_options_function_for_xtream_target};
 use crate::utils::{get_u32_from_serde_value, get_u64_from_serde_value};
 use serde_json::{Map, Value};
diff --git a/src/repository/bplustree.rs b/src/repository/bplustree.rs
index 92e00de98..bf83bcc6f 100644
--- a/src/repository/bplustree.rs
+++ b/src/repository/bplustree.rs
@@ -3,7 +3,7 @@ use std::io::{self, BufReader, Read, Seek, SeekFrom, Write};
 use std::marker::PhantomData;
 use std::mem::size_of;
 use std::path::Path;
-use crate::m3u_filter_error::{str_to_io_error, to_io_error};
+use crate::tuliprox_error::{str_to_io_error, to_io_error};
 use crate::utils::file_utils::{file_reader, file_writer, open_read_write_file, rename_or_copy};
 use log::error;
 use ruzstd::decoding::StreamingDecoder;
diff --git a/src/repository/epg_repository.rs b/src/repository/epg_repository.rs
index 05ee983c6..d2234f02d 100644
--- a/src/repository/epg_repository.rs
+++ b/src/repository/epg_repository.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{notify_err, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{notify_err, M3uFilterError, M3uFilterErrorKind};
 use crate::model::{Config, ConfigTarget, TargetOutput};
 use crate::model::Epg;
 use crate::repository::m3u_repository::m3u_get_epg_file_path;
diff --git a/src/repository/indexed_document.rs b/src/repository/indexed_document.rs
index 212602f65..7bcfe96c2 100644
--- a/src/repository/indexed_document.rs
+++ b/src/repository/indexed_document.rs
@@ -9,7 +9,7 @@ use crate::utils::file_utils;
 use log::error;
 use serde::{Deserialize, Serialize};
 use tempfile::NamedTempFile;
-use crate::m3u_filter_error::{str_to_io_error, to_io_error};
+use crate::tuliprox_error::{str_to_io_error, to_io_error};
 use crate::utils::{bincode_deserialize, bincode_serialize};
 use crate::utils::file_utils::{create_new_file_for_read_write, file_reader, file_writer, open_read_write_file, open_readonly_file, rename_or_copy};
 
diff --git a/src/repository/kodi_repository.rs b/src/repository/kodi_repository.rs
index 903d5c4dd..a1977c6f2 100644
--- a/src/repository/kodi_repository.rs
+++ b/src/repository/kodi_repository.rs
@@ -1,5 +1,5 @@
-use crate::m3u_filter_error::{create_m3u_filter_error_result, info_err};
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{create_tuliprox_error_result, info_err};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::{ApiProxyServerInfo, ProxyUserCredentials};
 use crate::model::{ClusterFlags, Config, ConfigTarget, StrmTargetOutput};
 use crate::model::{
@@ -408,7 +408,7 @@ async fn prepare_strm_output_directory(path: &Path) -> Result<(), M3uFilterError
     // Ensure the directory exists
     if let Err(e) = tokio::fs::create_dir_all(path).await {
         error!("Failed to create directory {path:?}: {e}");
-        return create_m3u_filter_error_result!(
+        return create_tuliprox_error_result!(
             M3uFilterErrorKind::Notify,
             "Error creating STRM directory: {e}"
         );
diff --git a/src/repository/m3u_playlist_iterator.rs b/src/repository/m3u_playlist_iterator.rs
index 5d1bca96c..858c83108 100644
--- a/src/repository/m3u_playlist_iterator.rs
+++ b/src/repository/m3u_playlist_iterator.rs
@@ -1,5 +1,5 @@
-use crate::m3u_filter_error::info_err;
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::info_err;
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::{ProxyType, ProxyUserCredentials};
 use crate::model::{Config, ConfigTarget, ConfigTargetOptions, TargetType};
 use crate::model::{M3uPlaylistItem, PlaylistItemType, XtreamCluster};
diff --git a/src/repository/m3u_repository.rs b/src/repository/m3u_repository.rs
index 00a4d50e6..e50f661c2 100644
--- a/src/repository/m3u_repository.rs
+++ b/src/repository/m3u_repository.rs
@@ -1,5 +1,5 @@
-use crate::m3u_filter_error::{create_m3u_filter_error,info_err};
-use crate::m3u_filter_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{create_tuliprox_error,info_err};
+use crate::tuliprox_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
 use crate::model::ProxyUserCredentials;
 use crate::model::{Config, ConfigTarget, M3uTargetOutput};
 use crate::model::{M3uPlaylistItem, PlaylistGroup, PlaylistItem, PlaylistItemType};
@@ -18,7 +18,7 @@ use crate::repository::storage_const;
 
 macro_rules! cant_write_result {
     ($path:expr, $err:expr) => {
-        create_m3u_filter_error!(M3uFilterErrorKind::Notify, "failed to write m3u playlist: {} - {}", $path.to_str().unwrap() ,$err)
+        create_tuliprox_error!(M3uFilterErrorKind::Notify, "failed to write m3u playlist: {} - {}", $path.to_str().unwrap() ,$err)
     }
 }
 
diff --git a/src/repository/playlist_repository.rs b/src/repository/playlist_repository.rs
index 8af0dd412..94c38750f 100644
--- a/src/repository/playlist_repository.rs
+++ b/src/repository/playlist_repository.rs
@@ -1,5 +1,5 @@
-use crate::m3u_filter_error::info_err;
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::info_err;
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::{Config, ConfigTarget, TargetOutput};
 use crate::model::{PlaylistGroup, PlaylistItemType};
 use crate::model::Epg;
diff --git a/src/repository/storage.rs b/src/repository/storage.rs
index 75626031c..ab6561894 100644
--- a/src/repository/storage.rs
+++ b/src/repository/storage.rs
@@ -1,9 +1,9 @@
 use std::path::{Path, PathBuf};
 use std::fmt::Write;
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::{Config};
 use crate::model::UUIDType;
-use crate::m3u_filter_error::{notify_err};
+use crate::tuliprox_error::{notify_err};
 use crate::repository::storage_const;
 use crate::utils::file_utils;
 
diff --git a/src/repository/xtream_playlist_iterator.rs b/src/repository/xtream_playlist_iterator.rs
index 48a363459..a0a8a91d7 100644
--- a/src/repository/xtream_playlist_iterator.rs
+++ b/src/repository/xtream_playlist_iterator.rs
@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 use log::error;
-use crate::m3u_filter_error::info_err;
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::info_err;
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::{ProxyUserCredentials};
 use crate::model::{Config, ConfigTarget, TargetType};
 use crate::model::{XtreamCluster, XtreamPlaylistItem};
diff --git a/src/repository/xtream_repository.rs b/src/repository/xtream_repository.rs
index 559c9a401..8861bcbf7 100644
--- a/src/repository/xtream_repository.rs
+++ b/src/repository/xtream_repository.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{create_m3u_filter_error, create_m3u_filter_error_result, info_err, notify_err, str_to_io_error, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{create_tuliprox_error, create_tuliprox_error_result, info_err, notify_err, str_to_io_error, M3uFilterError, M3uFilterErrorKind};
 use crate::model::{ProxyUserCredentials};
 use crate::model::{Config, ConfigInput, ConfigTarget, XtreamTargetOutput};
 use crate::model::{PlaylistEntry, PlaylistGroup, PlaylistItem, PlaylistItemType, XtreamCluster, XtreamPlaylistItem};
@@ -31,7 +31,7 @@ use std::sync::Arc;
 
 macro_rules! cant_write_result {
     ($path:expr, $err:expr) => {
-        create_m3u_filter_error!(
+        create_tuliprox_error!(
             M3uFilterErrorKind::Notify,
             "failed to write xtream playlist: {} - {}",
             $path.to_str().unwrap(),
@@ -280,7 +280,7 @@ pub async fn xtream_write_playlist(
     }
 
     if !errors.is_empty() {
-        return create_m3u_filter_error_result!(
+        return create_tuliprox_error_result!(
             M3uFilterErrorKind::Notify,
             "{}",
             errors.join("\n")
diff --git a/src/utils/bincode_utils.rs b/src/utils/bincode_utils.rs
index cb8beaf1d..f55d680f1 100644
--- a/src/utils/bincode_utils.rs
+++ b/src/utils/bincode_utils.rs
@@ -1,5 +1,5 @@
 use std::io;
-use crate::m3u_filter_error::to_io_error;
+use crate::tuliprox_error::to_io_error;
 
 #[inline]
 pub fn bincode_serialize<T>(value: &T) -> io::Result<Vec<u8>>
diff --git a/src/utils/crypto_utils.rs b/src/utils/crypto_utils.rs
index de7d74774..6e4b99824 100644
--- a/src/utils/crypto_utils.rs
+++ b/src/utils/crypto_utils.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use base64::{engine::general_purpose, Engine as _};
 use openssl::symm::{Cipher, Crypter, Mode};
 use rand::Rng;
diff --git a/src/utils/file/config_reader.rs b/src/utils/file/config_reader.rs
index f43fa2dea..7b5383f14 100644
--- a/src/utils/file/config_reader.rs
+++ b/src/utils/file/config_reader.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{create_m3u_filter_error, create_m3u_filter_error_result, handle_m3u_filter_error_result, info_err, str_to_io_error, to_io_error, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{create_tuliprox_error, create_tuliprox_error_result, handle_tuliprox_error_result, info_err, str_to_io_error, to_io_error, M3uFilterError, M3uFilterErrorKind};
 use crate::model::ApiProxyConfig;
 use crate::model::{Config, ConfigDto, ConfigInput, ConfigInputAlias, InputType};
 use crate::model::Mappings;
@@ -92,11 +92,11 @@ pub fn read_config(config_path: &str, config_file: &str, sources_file: &str, inc
                     }
                 }
                 Err(e) => {
-                    create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant read config file: {}", e)
+                    create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant read config file: {}", e)
                 }
             }
         }
-        Err(err) => create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "{}", err)
+        Err(err) => create_tuliprox_error_result!(M3uFilterErrorKind::Info, "{}", err)
     }
 }
 
@@ -106,7 +106,7 @@ pub fn read_mapping(mapping_file: &str, resolve_var: bool) -> Result<Option<Mapp
         let mapping: Result<Mappings, _> = serde_yaml::from_reader(config_file_reader(file, resolve_var));
         return match mapping {
             Ok(mut result) => {
-                handle_m3u_filter_error_result!(M3uFilterErrorKind::Info, result.prepare());
+                handle_tuliprox_error_result!(M3uFilterErrorKind::Info, result.prepare());
                 Ok(Some(result))
             }
             Err(err) => {
@@ -157,7 +157,7 @@ where
 
     File::create(&path)
         .and_then(|f| serde_yaml::to_writer(f, &config).map_err(to_io_error))
-        .map_err(|err| create_m3u_filter_error!(M3uFilterErrorKind::Info, "Could not write file {}: {}", &path.to_str().unwrap_or("?"), err))
+        .map_err(|err| create_tuliprox_error!(M3uFilterErrorKind::Info, "Could not write file {}: {}", &path.to_str().unwrap_or("?"), err))
 }
 
 pub fn save_api_proxy(file_path: &str, backup_dir: &str, config: &ApiProxyConfig) -> Result<(), M3uFilterError> {
diff --git a/src/utils/file/file_lock_manager.rs b/src/utils/file/file_lock_manager.rs
index 84bfe58cf..c460dc015 100644
--- a/src/utils/file/file_lock_manager.rs
+++ b/src/utils/file/file_lock_manager.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use std::{fmt, io};
 use std::path::{Path, PathBuf};
 use tokio::sync::{Mutex, RwLock, RwLockReadGuard, RwLockWriteGuard};
-use crate::m3u_filter_error::str_to_io_error;
+use crate::tuliprox_error::str_to_io_error;
 
 #[derive(Clone)]
 pub struct FileLockManager {
diff --git a/src/utils/file/file_utils.rs b/src/utils/file/file_utils.rs
index 7fdf74abb..99c71e24f 100644
--- a/src/utils/file/file_utils.rs
+++ b/src/utils/file/file_utils.rs
@@ -4,7 +4,7 @@ use std::fs::{File, OpenOptions};
 use std::io::{BufReader, BufWriter, Read, Write};
 use std::path::{Path, PathBuf};
 
-use crate::m3u_filter_error::str_to_io_error;
+use crate::tuliprox_error::str_to_io_error;
 use crate::utils::debug_if_enabled;
 use log::{debug, error};
 use path_clean::PathClean;
diff --git a/src/utils/network/epg.rs b/src/utils/network/epg.rs
index 64508dcde..b3d53b7e7 100644
--- a/src/utils/network/epg.rs
+++ b/src/utils/network/epg.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::M3uFilterError;
+use crate::tuliprox_error::M3uFilterError;
 use crate::model::{Config, ConfigInput};
 use crate::model::TVGuide;
 use crate::repository::storage::short_hash;
diff --git a/src/utils/network/ip_checker.rs b/src/utils/network/ip_checker.rs
index dc4d25a91..9424f8fee 100644
--- a/src/utils/network/ip_checker.rs
+++ b/src/utils/network/ip_checker.rs
@@ -1,4 +1,4 @@
-use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
 use crate::model::IpCheckConfig;
 use regex::Regex;
 use reqwest::Client;
diff --git a/src/utils/network/m3u.rs b/src/utils/network/m3u.rs
index c0a710823..1d1592d0f 100644
--- a/src/utils/network/m3u.rs
+++ b/src/utils/network/m3u.rs
@@ -1,5 +1,5 @@
 use std::sync::Arc;
-use crate::m3u_filter_error::M3uFilterError;
+use crate::tuliprox_error::M3uFilterError;
 use crate::model::{Config, ConfigInput};
 use crate::model::PlaylistGroup;
 use crate::processing::parser::m3u;
diff --git a/src/utils/network/request.rs b/src/utils/network/request.rs
index 19a44dcec..3014395ca 100644
--- a/src/utils/network/request.rs
+++ b/src/utils/network/request.rs
@@ -14,8 +14,8 @@ use reqwest::header::CONTENT_ENCODING;
 use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 use url::Url;
 
-use crate::m3u_filter_error::create_m3u_filter_error_result;
-use crate::m3u_filter_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
+use crate::tuliprox_error::create_tuliprox_error_result;
+use crate::tuliprox_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
 use crate::model::format_elapsed_time;
 use crate::model::{ConfigInput, ProxyConfig, InputFetchMethod};
 use crate::repository::storage::{get_input_storage_path, short_hash};
@@ -36,7 +36,7 @@ pub async fn get_input_text_content_as_file(client: Arc<reqwest::Client>, input:
             Ok(content) => Ok(content),
             Err(e) => {
                 error!("cant download input url: {}  => {}", sanitize_sensitive_info(url_str), sanitize_sensitive_info(e.to_string().as_str()));
-                create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to download")
+                create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to download")
             }
         }
     } else {
@@ -49,7 +49,7 @@ pub async fn get_input_text_content_as_file(client: Arc<reqwest::Client>, input:
                             Ok(_) => {}
                             Err(e) => {
                                 error!("cant persist to: {}  => {}", to_file.to_str().unwrap_or("?"), e);
-                                return create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to persist: {}  => {}", to_file.to_str().unwrap_or("?"), e);
+                                return create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to persist: {}  => {}", to_file.to_str().unwrap_or("?"), e);
                             }
                         }
                     }
@@ -57,7 +57,7 @@ pub async fn get_input_text_content_as_file(client: Arc<reqwest::Client>, input:
                     if filepath.exists() {
                         Some(filepath)
                     } else {
-                        return create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed: file does not exists {filepath:?}");
+                        return create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed: file does not exists {filepath:?}");
                     }
                 } else {
                     None
@@ -69,7 +69,7 @@ pub async fn get_input_text_content_as_file(client: Arc<reqwest::Client>, input:
         result.map_or_else(|| {
             let msg = format!("cant read input url: {}", sanitize_sensitive_info(url_str));
             error!("{msg}");
-            create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "{msg}")
+            create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "{msg}")
         }, Ok)
     }
 }
@@ -83,7 +83,7 @@ pub async fn get_input_text_content(client: Arc<reqwest::Client>, input: &Config
             Ok((content, _response_url)) => Ok(content),
             Err(e) => {
                 error!("cant download input url: {}  => {}", sanitize_sensitive_info(url_str), sanitize_sensitive_info(e.to_string().as_str()));
-                create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to download")
+                create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to download")
             }
         }
     } else {
@@ -96,7 +96,7 @@ pub async fn get_input_text_content(client: Arc<reqwest::Client>, input: &Config
                             Ok(_) => {}
                             Err(e) => {
                                 error!("cant persist to: {}  => {}", to_file.to_str().unwrap_or("?"), e);
-                                return create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to persist: {}  => {}", to_file.to_str().unwrap_or("?"), e);
+                                return create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to persist: {}  => {}", to_file.to_str().unwrap_or("?"), e);
                             }
                         }
                     }
@@ -104,7 +104,7 @@ pub async fn get_input_text_content(client: Arc<reqwest::Client>, input: &Config
                     match get_local_file_content(&filepath) {
                         Ok(content) => Some(content),
                         Err(err) => {
-                            return create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed : {}", err);
+                            return create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed : {}", err);
                         }
                     }
                 } else {
@@ -116,7 +116,7 @@ pub async fn get_input_text_content(client: Arc<reqwest::Client>, input: &Config
         result.map_or_else(|| {
             let msg = format!("cant read input url: {}", sanitize_sensitive_info(url_str));
             error!("{msg}");
-            create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "{msg}")
+            create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "{msg}")
         }, Ok)
     }
 }
@@ -363,7 +363,7 @@ async fn download_json_content(client: Arc<reqwest::Client>, input: &ConfigInput
 pub async fn get_input_json_content(client: Arc<reqwest::Client>, input: &ConfigInput, url: &str, persist_filepath: Option<PathBuf>) -> Result<serde_json::Value, M3uFilterError> {
     match download_json_content(client, input, url, persist_filepath).await {
         Ok(content) => Ok(content),
-        Err(e) => create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "cant download input url: {}  => {}", sanitize_sensitive_info(url), sanitize_sensitive_info(e.to_string().as_str()))
+        Err(e) => create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "cant download input url: {}  => {}", sanitize_sensitive_info(url), sanitize_sensitive_info(e.to_string().as_str()))
     }
 }
 
diff --git a/src/utils/network/xtream.rs b/src/utils/network/xtream.rs
index f341b50b5..579eee47a 100644
--- a/src/utils/network/xtream.rs
+++ b/src/utils/network/xtream.rs
@@ -1,5 +1,5 @@
 use std::sync::Arc;
-use crate::m3u_filter_error::{str_to_io_error, M3uFilterError};
+use crate::tuliprox_error::{str_to_io_error, M3uFilterError};
 use crate::model::{Config, ConfigInput, ConfigTarget};
 use crate::model::{PlaylistEntry, PlaylistGroup, XtreamCluster, XtreamPlaylistItem};
 use crate::processing::parser::xtream;