commands: split response tokenizer into separate file

src/commands.rs

@@ -1,6 +1,4 @@
-use std::collections::{HashMap, HashSet};
-
-use crate::{Request, request_tokenizer::RequestTokenizer};
+use crate::{Request, request_tokenizer::RequestTokenizer, response_tokenizer::ResponseAttributes};
 
 mod audio_output_devices;
 mod client_to_client;
@@ -69,11 +67,9 @@ pub trait Command {
         Self::parse_request(tokenized).map(|(req, _)| (req, rest))
     }
 
-    fn parse_response(
-        parts: ResponseAttributes<'_>,
-    ) -> Result<Self::Response, ResponseParserError<'_>>;
+    fn parse_response(parts: ResponseAttributes<'_>) -> ResponseParserResult<'_, Self::Response>;
 
-    fn parse_raw_response(raw: &str) -> Result<Self::Response, ResponseParserError<'_>> {
+    fn parse_raw_response(raw: &str) -> ResponseParserResult<'_, Self::Response> {
         Self::parse_response(ResponseAttributes::new(raw)?)
     }
 }
@@ -90,6 +86,8 @@ pub enum RequestParserError {
     MissingNewline,
 }
 
+pub type ResponseParserResult<'a, T> = Result<T, ResponseParserError<'a>>;
+
 // TODO: should these be renamed to fit the mpd docs?
 //       "Attribute" instead of "Property"?
 #[derive(Debug, Clone, PartialEq)]
@@ -115,265 +113,6 @@ pub enum ResponseParserError<'a> {
     // MissingNewline,
 }
 
-pub type GenericResponseResult<'a> = Result<GenericResponse<'a>, &'a str>;
-
-pub type GenericResponse<'a> = HashMap<&'a str, GenericResponseValue<'a>>;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum GenericResponseValue<'a> {
-    Text(&'a str),
-    Binary(&'a [u8]),
-    // Many(Vec<GenericResponseValue<'a>>),
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct ResponseAttributes<'a>(Vec<(&'a str, GenericResponseValue<'a>)>);
-
-impl<'a> ResponseAttributes<'a> {
-    pub fn new(raw: &'a str) -> Result<Self, ResponseParserError<'a>> {
-        let mut parts = Vec::new();
-        let mut lines = raw.lines();
-        loop {
-            let line = lines.next().ok_or(ResponseParserError::UnexpectedEOF)?;
-            if line.is_empty() {
-                println!("Warning: empty line in response");
-                continue;
-            }
-
-            if line == "OK" {
-                break;
-            }
-
-            let mut keyval = line.splitn(2, ": ");
-            let key = keyval
-                .next()
-                .ok_or(ResponseParserError::SyntaxError(0, line))?;
-
-            // TODO: handle binary data, also verify binarylimit
-            let value = keyval
-                .next()
-                .ok_or(ResponseParserError::SyntaxError(0, line))?;
-
-            parts.push((key, GenericResponseValue::Text(value)));
-        }
-
-        Ok(parts.into())
-    }
-
-    // pub fn get<'a>(&self, key: &str) -> Option<&GenericResponseValue<'a>> {
-    //     self.0.iter().find_map(|(k, v)| if k == &key { Some(v) } else { None })
-    // }
-}
-
-impl ResponseAttributes<'_> {
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-impl<'a> From<HashMap<&'a str, GenericResponseValue<'a>>> for ResponseAttributes<'a> {
-    fn from(map: HashMap<&'a str, GenericResponseValue<'a>>) -> Self {
-        Self(map.into_iter().collect())
-    }
-}
-
-impl<'a> From<ResponseAttributes<'a>> for HashMap<&'a str, GenericResponseValue<'a>> {
-    fn from(val: ResponseAttributes<'a>) -> Self {
-        debug_assert!({
-            let mut uniq = HashSet::new();
-            val.0.iter().all(move |x| uniq.insert(*x))
-        });
-
-        val.0.into_iter().collect()
-    }
-}
-
-impl<'a> From<ResponseAttributes<'a>> for Vec<(&'a str, GenericResponseValue<'a>)> {
-    fn from(val: ResponseAttributes<'a>) -> Self {
-        val.0
-    }
-}
-
-impl<'a> From<Vec<(&'a str, GenericResponseValue<'a>)>> for ResponseAttributes<'a> {
-    fn from(val: Vec<(&'a str, GenericResponseValue<'a>)>) -> Self {
-        Self(val)
-    }
-}
-
-// TODO: There should probably be a helper that lets you extract and verify one, two or maybe
-//       three properties without having to allocate a hashmap to get a nice API. We can retrieve
-//       the properties by name with a loop on the inner vec.
-
-/*******************/
-/* Parsing Helpers */
-/*******************/
-
-macro_rules! _expect_property_type {
-    ($property:expr, $name:expr, $variant:ident) => {
-        match $property {
-            Some(crate::commands::GenericResponseValue::$variant(value)) => Some(value),
-            Some(value) => {
-                let actual_type = match value {
-                    crate::commands::GenericResponseValue::Text(_) => "Text",
-                    crate::commands::GenericResponseValue::Binary(_) => "Binary",
-                };
-                return Err(
-                    crate::commands::ResponseParserError::UnexpectedPropertyType(
-                        $name,
-                        actual_type,
-                    ),
-                );
-            }
-            None => None,
-        }
-    };
-}
-
-macro_rules! _parse_optional_property_type {
-    ($name:expr, $property:expr) => {
-        $property
-            .map(|value| {
-                value.parse().map_err(|_| {
-                    crate::commands::ResponseParserError::InvalidProperty($name, value)
-                })
-            })
-            .transpose()?
-    };
-}
-
-macro_rules! _unwrap_optional_property_type {
-    ($name:expr, $property:expr) => {
-        match $property {
-            Some(value) => value,
-            None => return Err(crate::commands::ResponseParserError::MissingProperty($name)),
-        }
-    };
-}
-
-macro_rules! expect_optional_property_type {
-    ($property:expr, $name:expr, $variant:ident) => {
-        crate::commands::_expect_property_type!($property, $name, $variant)
-    };
-}
-
-macro_rules! expect_property_type {
-    ($property:expr, $name:expr, $variant:ident) => {{
-        let prop = crate::commands::_expect_property_type!($property, $name, $variant);
-        crate::commands::_unwrap_optional_property_type!($name, prop)
-    }};
-}
-
-macro_rules! get_optional_property {
-    ($parts:expr, $name:literal, $variant:ident) => {
-        crate::commands::_expect_property_type!({ $parts.get($name).map(|v| *v) }, $name, $variant)
-    };
-}
-
-macro_rules! get_property {
-    ($parts:expr, $name:literal, $variant:ident) => {{
-        let prop = crate::commands::_expect_property_type!(
-            { $parts.get($name).map(|v| *v) },
-            $name,
-            $variant
-        );
-        crate::commands::_unwrap_optional_property_type!($name, prop)
-    }};
-}
-
-macro_rules! get_and_parse_optional_property {
-    ($parts:ident, $name:literal, $variant:ident) => {{
-        let prop = crate::commands::_expect_property_type!(
-            { $parts.get($name).map(|v| *v) },
-            $name,
-            $variant
-        );
-        crate::commands::_parse_optional_property_type!($name, prop)
-    }};
-}
-
-macro_rules! get_and_parse_property {
-    ($parts:ident, $name:literal, $variant:ident) => {{
-        let prop = crate::commands::_expect_property_type!(
-            { $parts.get($name).map(|v| *v) },
-            $name,
-            $variant
-        );
-        let prop = crate::commands::_parse_optional_property_type!($name, prop);
-        crate::commands::_unwrap_optional_property_type!($name, prop)
-    }};
-}
-
-macro_rules! get_next_optional_property {
-    ($parts:ident, $variant:ident) => {
-        match $parts.next() {
-            Some((name, value)) => {
-                crate::commands::_expect_property_type!({ Some(value) }, name, $variant)
-                    .map(|value| (name, value))
-            }
-            None => None,
-        }
-    };
-}
-
-macro_rules! get_next_property {
-    ($parts:ident, $variant:ident) => {
-        match $parts.next() {
-            Some((name, value)) => (
-                name,
-                crate::commands::_expect_property_type!({ Some(value) }, name, $variant).unwrap(),
-            ),
-            None => return Err(crate::commands::ResponseParserError::UnexpectedEOF),
-        }
-    };
-}
-
-macro_rules! get_next_and_parse_optional_property {
-    ($parts:ident, $variant:ident) => {
-        match $parts.next() {
-            Some((name, value)) => {
-                let prop = crate::commands::_expect_property_type!({ Some(value) }, name, $variant);
-                prop.map(|value| {
-                    (
-                        name,
-                        crate::commands::_parse_optional_property_type!(name, value),
-                    )
-                })
-            }
-            None => None,
-        }
-    };
-}
-
-macro_rules! get_next_and_parse_property {
-    ($parts:ident, $variant:ident) => {
-        match $parts.next() {
-            Some((name, value)) => {
-                let prop = crate::commands::_expect_property_type!({ Some(value) }, name, $variant);
-                let prop = crate::commands::_parse_optional_property_type!(name, prop);
-                (
-                    name,
-                    crate::commands::_unwrap_optional_property_type!(name, prop),
-                )
-            }
-            None => return Err(crate::commands::ResponseParserError::UnexpectedEOF),
-        }
-    };
-}
-
-pub(crate) use _expect_property_type;
-pub(crate) use _parse_optional_property_type;
-pub(crate) use _unwrap_optional_property_type;
-pub(crate) use expect_property_type;
-// pub(crate) use expect_optional_property_type;
-pub(crate) use get_and_parse_optional_property;
-pub(crate) use get_and_parse_property;
-// pub(crate) use get_next_and_parse_optional_property;
-pub(crate) use get_next_and_parse_property;
-// pub(crate) use get_next_optional_property;
-pub(crate) use get_next_property;
-pub(crate) use get_optional_property;
-pub(crate) use get_property;
-
 /*******************/
 
 pub const COMMAND_NAMES: &[&str] = &[
@@ -522,39 +261,3 @@ pub const COMMAND_NAMES: &[&str] = &[
     Save::COMMAND,
     SearchPlaylist::COMMAND,
 ];
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    #[cfg(debug_assertions)]
-    fn test_valid_hashmap_uniqueness_assert() {
-        let valid_maplike_attrs: ResponseAttributes = vec![
-            ("a", GenericResponseValue::Text("1")),
-            ("A", GenericResponseValue::Text("2")),
-            ("A ", GenericResponseValue::Text("3")),
-            ("b", GenericResponseValue::Text("4")),
-        ]
-        .into();
-
-        let map: HashMap<_, _> = valid_maplike_attrs.into();
-        assert_eq!(map.len(), 4);
-    }
-
-    #[test]
-    #[cfg(debug_assertions)]
-    #[should_panic]
-    fn test_invalid_hashmap_uniqueness_assert() {
-        let invalid_maplike_attrs: ResponseAttributes = vec![
-            ("a", GenericResponseValue::Text("1")),
-            ("b", GenericResponseValue::Text("2")),
-            ("c", GenericResponseValue::Text("3")),
-            ("a", GenericResponseValue::Text("4")),
-        ]
-        .into();
-
-        let map: HashMap<_, _> = invalid_maplike_attrs.into();
-        assert_eq!(map.len(), 4);
-    }
-}

src/commands/audio_output_devices/disableoutput.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::AudioOutputId,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct DisableOutput;

src/commands/audio_output_devices/enableoutput.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::AudioOutputId,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct EnableOutput;

src/commands/audio_output_devices/outputs.rs

@@ -3,11 +3,9 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-        expect_property_type,
-    },
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct Outputs;
@@ -38,7 +36,7 @@ impl Command for Outputs {
     }
 
     fn parse_response(
-        _parts: ResponseAttributes<'_>,
+        parts: ResponseAttributes<'_>,
     ) -> Result<Self::Response, ResponseParserError<'_>> {
         let mut outputs = Vec::new();
 
@@ -48,7 +46,7 @@ impl Command for Outputs {
         let mut enabled: Option<bool> = None;
         let mut attributes: HashMap<String, String> = HashMap::new();
 
-        for (k, v) in _parts.0.into_iter() {
+        for (k, v) in Vec::from(parts).into_iter() {
             match k {
                 "outputid" => {
                     // Reset and store the previous output if all fields are present

src/commands/audio_output_devices/outputset.rs

@@ -1,12 +1,10 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::AudioOutputId,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct OutputSet;

src/commands/audio_output_devices/toggleoutput.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::AudioOutputId,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct ToggleOutput;

src/commands/client_to_client/channels.rs

@@ -1,12 +1,10 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-        expect_property_type,
-    },
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     common::ChannelName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct Channels;

src/commands/client_to_client/readmessages.rs

@@ -1,12 +1,10 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-        expect_property_type,
-    },
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     common::ChannelName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct ReadMessages;

src/commands/client_to_client/sendmessage.rs

@@ -1,12 +1,10 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::ChannelName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct SendMessage;

src/commands/client_to_client/subscribe.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::ChannelName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Subscribe;

src/commands/client_to_client/unsubscribe.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::ChannelName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Unsubscribe;

src/commands/connection_settings/binary_limit.rs

@@ -1,9 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct BinaryLimit;

src/commands/connection_settings/close.rs

@@ -1,6 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Close;

src/commands/connection_settings/kill.rs

@@ -1,6 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Kill;

src/commands/connection_settings/password.rs

@@ -1,9 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Password;

src/commands/connection_settings/ping.rs

@@ -1,6 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Ping;

src/commands/connection_settings/protocol.rs

@@ -1,9 +1,8 @@
 use crate::{
     Request,
+    commands::{Command, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserResult, ResponseAttributes, ResponseParserError, expect_property_type,
-    },
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct Protocol;
@@ -27,12 +26,12 @@ impl Command for Protocol {
     fn parse_response(
         parts: ResponseAttributes<'_>,
     ) -> Result<Self::Response, ResponseParserError<'_>> {
-        if let Some((k, _)) = parts.0.iter().find(|(k, _)| *k != "feature") {
+        let parts_: Vec<_> = parts.into();
+        if let Some((k, _)) = parts_.iter().find(|(k, _)| *k != "feature") {
             return Err(ResponseParserError::UnexpectedProperty(k));
         }
 
-        let list = parts
-            .0
+        let list = parts_
             .into_iter()
             .map(|(k, v)| Ok(expect_property_type!(Some(v), k, Text).to_string()))
             .collect::<Result<Vec<_>, ResponseParserError>>()?;

src/commands/connection_settings/protocol_all.rs

@@ -1,7 +1,8 @@
 use crate::{
     Request,
+    commands::{Command, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct ProtocolAll;

src/commands/connection_settings/protocol_available.rs

@@ -1,9 +1,8 @@
 use crate::{
     Request,
+    commands::{Command, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserResult, ResponseAttributes, ResponseParserError, expect_property_type,
-    },
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct ProtocolAvailable;
@@ -27,12 +26,12 @@ impl Command for ProtocolAvailable {
     fn parse_response(
         parts: ResponseAttributes<'_>,
     ) -> Result<Self::Response, ResponseParserError<'_>> {
-        if let Some((k, _)) = parts.0.iter().find(|(k, _)| *k != "feature") {
+        let parts_: Vec<_> = parts.into();
+        if let Some((k, _)) = parts_.iter().find(|(k, _)| *k != "feature") {
             return Err(ResponseParserError::UnexpectedProperty(k));
         }
 
-        let list = parts
-            .0
+        let list = parts_
             .into_iter()
             .map(|(k, v)| Ok(expect_property_type!(Some(v), k, Text).to_string()))
             .collect::<Result<Vec<_>, ResponseParserError>>()?;

src/commands/connection_settings/protocol_clear.rs

@@ -1,7 +1,8 @@
 use crate::{
     Request,
+    commands::{Command, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct ProtocolClear;

src/commands/connection_settings/protocol_disable.rs

@@ -1,10 +1,9 @@
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::Feature,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct ProtocolDisable;

src/commands/connection_settings/protocol_enable.rs

@@ -1,10 +1,9 @@
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::Feature,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct ProtocolEnable;

src/commands/connection_settings/tag_types.rs

@@ -1,9 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-        expect_property_type,
-    },
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct TagTypes;

src/commands/connection_settings/tag_types_all.rs

@@ -1,7 +1,8 @@
 use crate::{
     Request,
+    commands::{Command, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct TagTypesAll;

src/commands/connection_settings/tag_types_available.rs

@@ -1,9 +1,8 @@
 use crate::{
     Request,
+    commands::{Command, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserResult, ResponseAttributes, ResponseParserError, expect_property_type,
-    },
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct TagTypesAvailable;

src/commands/connection_settings/tag_types_clear.rs

@@ -1,7 +1,8 @@
 use crate::{
     Request,
+    commands::{Command, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct TagTypesClear;

src/commands/connection_settings/tag_types_disable.rs

@@ -1,10 +1,9 @@
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::TagName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct TagTypesDisable;

src/commands/connection_settings/tag_types_enable.rs

@@ -1,10 +1,9 @@
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::TagName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct TagTypesEnable;

src/commands/connection_settings/tag_types_reset.rs

@@ -1,10 +1,9 @@
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::TagName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct TagTypesReset;

src/commands/controlling_playback/next.rs

@@ -1,6 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Next;

src/commands/controlling_playback/pause.rs

@@ -1,9 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Pause;

src/commands/controlling_playback/play.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::SongPosition,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Play;

src/commands/controlling_playback/playid.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::SongId,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct PlayId;

src/commands/controlling_playback/previous.rs

@@ -1,6 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Previous;

src/commands/controlling_playback/seek.rs

@@ -1,12 +1,10 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::{SongPosition, TimeWithFractions},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Seek;

src/commands/controlling_playback/seekcur.rs

@@ -1,12 +1,12 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
     },
     common::{SeekMode, TimeWithFractions},
+    request_tokenizer::RequestTokenizer,
 };
 
 pub struct SeekCur;

src/commands/controlling_playback/seekid.rs

@@ -1,12 +1,10 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::{SongId, TimeWithFractions},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct SeekId;

src/commands/controlling_playback/stop.rs

@@ -1,6 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Stop;

src/commands/mounts_and_neighbors/listmounts.rs

@@ -1,9 +1,8 @@
 use crate::{
     Request,
+    commands::{Command, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserResult, ResponseAttributes, ResponseParserError, expect_property_type,
-    },
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct ListMounts;

src/commands/mounts_and_neighbors/listneighbors.rs

@@ -2,10 +2,9 @@ use std::collections::HashMap;
 
 use crate::{
     Request,
+    commands::{Command, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserResult, ResponseAttributes, ResponseParserError, expect_property_type,
-    },
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct ListNeighbors;

src/commands/mounts_and_neighbors/mount.rs

@@ -2,10 +2,9 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Mount;

src/commands/mounts_and_neighbors/unmount.rs

@@ -1,9 +1,8 @@
 use crate::{
     Request,
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Unmount;

src/commands/music_database/albumart.rs

@@ -3,12 +3,10 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError, get_and_parse_property, get_property,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::{Offset, Uri},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, get_and_parse_property, get_property},
 };
 
 pub struct AlbumArt;

src/commands/music_database/count.rs

@@ -3,13 +3,11 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError, get_and_parse_property,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::GroupType,
     filter::Filter,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, get_and_parse_property},
 };
 
 pub struct Count;

src/commands/music_database/find.rs

@@ -1,13 +1,11 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::{Sort, WindowRange},
     filter::Filter,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Find;

src/commands/music_database/findadd.rs

@@ -1,13 +1,11 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::{SongPosition, Sort, WindowRange},
     filter::Filter,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct FindAdd;

src/commands/music_database/getfingerprint.rs

@@ -3,12 +3,10 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError, get_and_parse_property,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::Uri,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, get_and_parse_property},
 };
 
 pub struct GetFingerprint;

src/commands/music_database/list.rs

@@ -1,13 +1,11 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError, expect_property_type,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::{GroupType, TagName},
     filter::Filter,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct List;
@@ -67,13 +65,13 @@ impl Command for List {
     fn parse_response(
         parts: ResponseAttributes<'_>,
     ) -> Result<Self::Response, ResponseParserError<'_>> {
+        let parts_: Vec<_> = parts.into();
         debug_assert!({
-            let key = parts.0.first().map(|(k, _)| k);
-            parts.0.iter().all(|(k, _)| k == key.unwrap())
+            let key = parts_.first().map(|(k, _)| k);
+            parts_.iter().all(|(k, _)| k == key.unwrap())
         });
 
-        let list = parts
-            .0
+        let list = parts_
             .into_iter()
             .map(|(k, v)| Ok(expect_property_type!(Some(v), k, Text).to_string()))
             .collect::<Result<Vec<_>, ResponseParserError>>()?;

src/commands/music_database/listall.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::Uri,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct ListAll;

src/commands/music_database/listallinfo.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::Uri,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct ListAllInfo;

src/commands/music_database/listfiles.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::Uri,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct ListFiles;

src/commands/music_database/lsinfo.rs

@@ -1,12 +1,10 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError, expect_property_type,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::Uri,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct LsInfo;

src/commands/music_database/readcomments.rs

@@ -1,12 +1,10 @@
 use std::collections::HashMap;
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, GenericResponseValue, Request, RequestParserError, RequestParserResult,
-        ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::Uri,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{GenericResponseValue, ResponseAttributes},
 };
 
 pub struct ReadComments;

src/commands/music_database/readpicture.rs

@@ -3,12 +3,12 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError, get_and_parse_property, get_optional_property, get_property,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::{Offset, Uri},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{
+        ResponseAttributes, get_and_parse_property, get_optional_property, get_property,
+    },
 };
 
 pub struct ReadPicture;

src/commands/music_database/rescan.rs

@@ -3,12 +3,10 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-        get_and_parse_property,
-    },
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     common::Uri,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, get_and_parse_property},
 };
 
 pub struct Rescan;

src/commands/music_database/search.rs

@@ -1,13 +1,11 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::{Sort, WindowRange},
     filter::Filter,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Search;

src/commands/music_database/searchadd.rs

@@ -1,13 +1,13 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
     },
     common::{SongPosition, Sort, WindowRange},
     filter::Filter,
+    request_tokenizer::RequestTokenizer,
 };
 
 pub struct SearchAdd;

src/commands/music_database/searchaddpl.rs

@@ -1,13 +1,13 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
     },
     common::{PlaylistName, SongPosition, Sort, WindowRange},
     filter::Filter,
+    request_tokenizer::RequestTokenizer,
 };
 
 pub struct SearchAddPl;

src/commands/music_database/searchcount.rs

@@ -3,13 +3,11 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError, get_and_parse_property,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::GroupType,
     filter::Filter,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, get_and_parse_property},
 };
 
 pub struct SearchCount;

src/commands/music_database/update.rs

@@ -3,12 +3,10 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-        get_and_parse_property,
-    },
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     common::Uri,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, get_and_parse_property},
 };
 
 pub struct Update;

src/commands/partition_commands/delpartition.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::PartitionName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct DelPartition;

src/commands/partition_commands/listpartitions.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-        expect_property_type,
-    },
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     common::PartitionName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, expect_property_type},
 };
 
 pub struct ListPartitions;

src/commands/partition_commands/moveoutput.rs

@@ -1,9 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct MoveOutput;

src/commands/partition_commands/newpartition.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::PartitionName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct NewPartition;

src/commands/partition_commands/partition.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::PartitionName,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Partition;

src/commands/playback_options/consume.rs

@@ -1,12 +1,10 @@
 use std::str::FromStr;
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::BoolOrOneshot,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Consume;

src/commands/playback_options/crossfade.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::Seconds,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Crossfade;

src/commands/playback_options/getvol.rs

@@ -1,12 +1,10 @@
 use std::collections::HashMap;
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-        get_and_parse_property,
-    },
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     common::VolumeValue,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, get_and_parse_property},
 };
 
 pub struct GetVol;

src/commands/playback_options/mixrampdb.rs

@@ -1,9 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct MixRampDb;

src/commands/playback_options/mixrampdelay.rs

@@ -1,10 +1,8 @@
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::Seconds,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct MixRampDelay;

src/commands/playback_options/random.rs

@@ -1,9 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Random;

src/commands/playback_options/repeat.rs

@@ -1,9 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Repeat;

src/commands/playback_options/replay_gain_mode.rs

@@ -1,12 +1,10 @@
 use std::str::FromStr;
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::ReplayGainModeMode,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct ReplayGainMode;

src/commands/playback_options/replay_gain_status.rs

@@ -3,12 +3,10 @@ use std::{collections::HashMap, str::FromStr};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-        get_property,
-    },
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     common::ReplayGainModeMode,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, get_property},
 };
 
 pub struct ReplayGainStatus;

src/commands/playback_options/setvol.rs

@@ -1,12 +1,10 @@
 use std::str::FromStr;
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::VolumeValue,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct SetVol;

src/commands/playback_options/single.rs

@@ -1,12 +1,10 @@
 use std::str::FromStr;
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::BoolOrOneshot,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Single;

src/commands/playback_options/volume.rs

@@ -1,12 +1,10 @@
 use std::str::FromStr;
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::VolumeValue,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Volume;

src/commands/querying_mpd_status/clearerror.rs

@@ -1,6 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 /// Clears the current error message in status (this is also accomplished by any command that starts playback)

src/commands/querying_mpd_status/currentsong.rs

@@ -1,8 +1,9 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 /// Displays the song info of the current song (same song that is identified in status)

src/commands/querying_mpd_status/idle.rs

@@ -1,10 +1,10 @@
 use std::str::FromStr;
 
-use crate::request_tokenizer::RequestTokenizer;
-use crate::common::SubSystem;
-
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
+    common::SubSystem,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Idle;

src/commands/querying_mpd_status/stats.rs

@@ -3,10 +3,10 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-        get_and_parse_optional_property, get_and_parse_property,
+    response_tokenizer::{
+        ResponseAttributes, get_and_parse_optional_property, get_and_parse_property,
     },
 };
 

src/commands/querying_mpd_status/status.rs

@@ -3,13 +3,14 @@ use std::str::FromStr;
 
 use serde::{Deserialize, Serialize};
 
-use crate::request_tokenizer::RequestTokenizer;
-use crate::common::{Audio, BoolOrOneshot, SongId, SongPosition};
-
-use crate::commands::{
-    Command, GenericResponseValue, Request, RequestParserResult, ResponseAttributes,
-    ResponseParserError, get_and_parse_optional_property, get_and_parse_property,
-    get_optional_property, get_property,
+use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
+    common::{Audio, BoolOrOneshot, SongId, SongPosition},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{
+        GenericResponseValue, ResponseAttributes, get_and_parse_optional_property,
+        get_and_parse_property, get_optional_property, get_property,
+    },
 };
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]

src/commands/queue/add.rs

@@ -1,12 +1,10 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::{SongPosition, Uri},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Add;

src/commands/queue/addid.rs

@@ -1,12 +1,10 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-        ResponseParserError, get_next_and_parse_property,
-    },
+    commands::{Command, Request, RequestParserError, RequestParserResult, ResponseParserError},
     common::{SongId, SongPosition, Uri},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::{ResponseAttributes, get_next_and_parse_property},
 };
 
 pub struct AddId;

src/commands/queue/addtagid.rs

@@ -2,11 +2,11 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
     common::{SongId, TagName, TagValue},
+    request_tokenizer::RequestTokenizer,
 };
 
 pub struct AddTagId;

src/commands/queue/clear.rs

@@ -1,6 +1,7 @@
 use crate::{
+    commands::{Command, Request, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Clear;

src/commands/queue/cleartagid.rs

@@ -2,11 +2,10 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::{SongId, TagName},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct ClearTagId;

src/commands/queue/delete.rs

@@ -2,11 +2,10 @@ use std::str::FromStr;
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::OneOrRange,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Delete;

src/commands/queue/deleteid.rs

@@ -1,10 +1,9 @@
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::SongId,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct DeleteId;

src/commands/queue/move_.rs

@@ -2,11 +2,11 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
     common::{AbsouluteRelativeSongPosition, OneOrRange},
+    request_tokenizer::RequestTokenizer,
 };
 
 pub struct Move;

src/commands/queue/moveid.rs

@@ -2,11 +2,11 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
     common::{AbsouluteRelativeSongPosition, SongId},
+    request_tokenizer::RequestTokenizer,
 };
 
 pub struct MoveId;

src/commands/queue/playlist.rs

@@ -1,7 +1,8 @@
 use crate::{
     Request,
+    commands::{Command, RequestParserResult, ResponseParserError},
     request_tokenizer::RequestTokenizer,
-    commands::{Command, RequestParserResult, ResponseAttributes, ResponseParserError},
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Playlist;

src/commands/queue/playlistfind.rs

@@ -2,12 +2,11 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::{Sort, WindowRange},
     filter::Filter,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct PlaylistFind;

src/commands/queue/playlistid.rs

@@ -1,10 +1,9 @@
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::SongId,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct PlaylistId;

src/commands/queue/playlistinfo.rs

@@ -1,10 +1,9 @@
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::OneOrRange,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct PlaylistInfo;

src/commands/queue/playlistsearch.rs

@@ -2,12 +2,11 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::{Sort, WindowRange},
     filter::Filter,
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct PlaylistSearch;

src/commands/queue/plchanges.rs

@@ -2,11 +2,10 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::{Version, WindowRange},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct PlChanges;

src/commands/queue/plchangesposid.rs

@@ -2,11 +2,10 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::{Version, WindowRange},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct PlChangesPosId;

src/commands/queue/prio.rs

@@ -2,11 +2,10 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::{Priority, WindowRange},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct Prio;

src/commands/queue/prioid.rs

@@ -2,11 +2,10 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
-    request_tokenizer::RequestTokenizer,
-    commands::{
-        Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
-    },
+    commands::{Command, RequestParserError, RequestParserResult, ResponseParserError},
     common::{Priority, SongId},
+    request_tokenizer::RequestTokenizer,
+    response_tokenizer::ResponseAttributes,
 };
 
 pub struct PrioId;