println!("{}", DataSelector::from_file("series_selector.keytree")
        .resume_into_data_spec(Country::UnitedKingdom, DataType::Inf)
        .unwrap()
        .keytree());

    // DataSpec::from_file("source_data.keytree").write(&root_dir);
    // let series_obs = Fred::series_observations("NORURTOTADSMEI").unwrap();
    // let () = series_obs;
    // Get series_spec using series_id    
    let series_spec = SeriesSpec::from_series_id("NORURTOTADSMEI", "source_data.keytree").unwrap();

//! println!("{}", DataSpec::from_selector(`series_selector.keytree`).unwrap().keytree());

//! println!("{}", DataSelector::from_file("series_selector.keytree")
//!     .into_data_spec()
//!     .unwrap()
//!     .keytree());

//! let data_spec = DataSpec::from_file("checked_data.keytree").into_indexed();

//! let data_spec = DataSpec::from_file("source_data.keytree").into_indexed();

    pub fn from_file(path: &str) -> Self {
        let source_spec = fs::read_to_string(path).unwrap();

    pub fn from_file(path: &str) -> Result<Self, Error> {
        let source_spec = match fs::read_to_string(path) {
            Ok(ss) => ss,
            Err(err) => { return Err(failed_to_read_file(&err.to_string())) },
        };

        kt.to_ref().try_into().unwrap()

        kt.to_ref().try_into().map_err(|err: keytree::error::Error| keytree_error(&err.to_string())) 

        for (series_id, _) in &self.reverse {
            let series_spec = self.get_series_spec(&series_id);
            series_spec.write_data(root_path);
            series_spec.write_meta(root_path); 

        for (_, series_specs) in &self.map {
            for series_spec in series_specs {
                series_spec.write_data(root_path);
                series_spec.write_meta(root_path); 
            }

        for (series_id, _) in &self.reverse {
            let series_spec = self.get_series_spec(series_id);
            kt.push_keytree(1, series_spec.keytree());

        for (_, series_specs) in &self.map {
            for series_spec in series_specs {
                kt.push_keytree(1, series_spec.keytree());
            }

    /// Return `Self` given a `series_id`.
    pub fn from_series_id(series_id: &str, root_path: &str) -> Result<Self, Error> {
        let sid = SeriesId::from_str(series_id).unwrap();
        let data_spec = DataSpec::from_file(root_path)?; 
        let key = match data_spec.reverse.get(&sid) {
            Some(key) => key,
            None => { return Err(series_id_not_in_dataspec(&series_id.to_string())) },
        };
        match data_spec.map.get(&key) {
            Some(series_specs) => {
                Ok(
                    series_specs.iter()
                        .find(|series_spec| series_spec.series_id == sid)
                        .unwrap()
                        .clone()
                )
            },
            None => unreachable!(),
        }
    }