diff --git a/src/config.rs b/src/config.rs
index 918ca25..ba7943a 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -396,29 +396,6 @@ impl Settings {
     }
 
 
-    /// Get server password from password_file or directly from config if configured
-    pub fn get_server_password(&self) -> Result<Option<String>> {
-        if let Some(server) = &self.server {
-            // First check for password_file
-            if let Some(password_file) = &server.password_file {
-                debug!("CONFIG: Reading password from file: {:?}", password_file);
-                let password = fs::read_to_string(password_file)
-                    .with_context(|| format!("Failed to read password file: {:?}", password_file))?
-                    .trim()
-                    .to_string();
-                return Ok(Some(password));
-            }
-            
-            // Fall back to direct password field
-            if let Some(password) = &server.password {
-                debug!("CONFIG: Using password from config");
-                return Ok(Some(password.clone()));
-            }
-        }
-        Ok(None)
-    }
-
-
     /// Get server password from password_file or directly from config if configured
     pub fn get_server_password(&self) -> Result<Option<String>> {
         if let Some(server) = &self.server {
diff --git a/src/parser/filter_parser.rs b/src/parser/filter_parser.rs
index a4c55fd..9c87268 100644
--- a/src/parser/filter_parser.rs
+++ b/src/parser/filter_parser.rs
@@ -6,8 +6,6 @@ use std::collections::HashMap;
 #[grammar = "filter.pest"]
 pub struct FilterParser;
 
-use self::Rule;
-
 #[derive(Debug)]
 pub struct Filter {
     pub name: String,
@@ -16,30 +14,30 @@ pub struct Filter {
 
 pub fn parse_filter_string(input: &str) -> Result<Vec<Filter>, Box<dyn std::error::Error>> {
     let mut filters = Vec::new();
-    let pairs = FilterParser::parse(Rule::filters, input)?;
+    let pairs = FilterParser::parse(FilterParser::Rule::filters, input)?;
     
     for pair in pairs {
-        if pair.as_rule() == Rule::filter {
+        if pair.as_rule() == FilterParser::Rule::filter {
             let mut name = String::new();
             let mut options = HashMap::new();
             
             for inner_pair in pair.into_inner() {
                 match inner_pair.as_rule() {
-                    Rule::filter_name => {
+                    FilterParser::Rule::filter_name => {
                         name = inner_pair.as_str().to_string();
                     }
-                    Rule::options => {
+                    FilterParser::Rule::options => {
                         for option_pair in inner_pair.into_inner() {
-                            if option_pair.as_rule() == Rule::option {
+                            if option_pair.as_rule() == FilterParser::Rule::option {
                                 let mut option_name = None;
                                 let mut option_value = None;
                                 
                                 for option_inner in option_pair.into_inner() {
                                     match option_inner.as_rule() {
-                                        Rule::option_name => {
+                                        FilterParser::Rule::option_name => {
                                             option_name = Some(option_inner.as_str().to_string());
                                         }
-                                        Rule::option_value => {
+                                        FilterParser::Rule::option_value => {
                                             option_value = Some(parse_option_value(option_inner.as_str())?);
                                         }
                                         _ => {}