currency_engineering/ui_data - Change TSY4YBBZ4AEW2JTEI4AS5FGTTUZR5WE3TENDHVIOWWY6V2DRT7ZQC

Changed ts Spec datastructures to new format.

Created by CrEcTsRjb1hHQjHuumqRfqdbVV4X58iLEubi4noaDPFa on July 20, 2021

TSY4YBBZ4AEW2JTEI4AS5FGTTUZR5WE3TENDHVIOWWY6V2DRT7ZQC

Dependencies

In channels

main

Change contents

File deletion: src.AZQVIGSM6OJHM, src
BF:BFD[1.0] → [3.36:64]
BF:BFD[3.64] → [4.2628:2628]
BFD:BFD[1.0] → [4.2622:2627]
BF:BFD[4.2627] → [4.2628:2628]

File deletion: lib.rs, lib.rs

BF:BFD[4.2628] → [3.88:105]

BF:BFD[3.105] → [4.21264:21264]

BFD:BFD[4.2628] → [4.21255:21263]

BF:BFD[4.21263] → [4.21264:21264]

B:BD[4.21264] → [4.21265:33347]

//! [Fred API key](https://fred.stlouisfed.org/docs/api/api_key.html) needs to
//! be stored as the environment variable FRED_API_KEY.
//! ```
//! use fred_api::Fred;
//! use fred_api::response::Categories;
//! 
//! let categories = Fred::category(125);
use std::env;
use std::fs;
use crate::response::*;
pub mod response;
pub struct Fred;
impl Fred {
    /// [Get a category](https://fred.stlouisfed.org/docs/api/fred/category.html)
    pub fn category(category_id: usize) -> Categories { 
        serde_json::from_str(&response(
            "category",
            vec!(
                format!("category_id={}", category_id)
            ),
        )).unwrap()
    }
    /// [Get the child categories for a specified parent category.](https://fred.stlouisfed.org/docs/api/fred/category_children.html)
    pub fn category_children(category_id: usize) -> Categories {
        serde_json::from_str(&response(
            "category/children",
            vec!(
                format!("category_id={}", category_id)
            ),
        )).unwrap()
    }
    
    /// [Get the related categories for a category.](https://fred.stlouisfed.org/docs/api/fred/category_related.html)
    pub fn category_related(category_id: usize) -> Categories {
        serde_json::from_str(&response(
            "category/related",
            vec!(
                format!("category_id={}", category_id)
            ),
        )).unwrap()
    }
    
    /// [Get the series in a category.](https://fred.stlouisfed.org/docs/api/fred/category_series.html)
    pub fn category_series(category_id: usize) -> CategorySeries {
        serde_json::from_str(&response(
            "category/series",
            vec!(
                format!("category_id={}", category_id)
            ),
        )).unwrap()
    }
    
    /// [Get the tags for a category.](https://fred.stlouisfed.org/docs/api/fred/category_tags.html)
    pub fn category_tags(category_id: usize) -> CategoryTags {
        serde_json::from_str(&response(
            "category/tags",
            vec!(
                format!("category_id={}", category_id)
            ),
        )).unwrap()
    }
    
    /// [Get the related tags for a category.](https://fred.stlouisfed.org/docs/api/fred/category_related_tags.html)
    pub fn category_related_tags(category_id: usize, tag_names: &str) -> CategoryRelatedTags {
        serde_json::from_str(&response(
            "category/related_tags",
            vec!(
                format!("category_id={}", category_id),
                format!("tag_names={}", tag_names),
            ),
        )).unwrap()
    }
    /// [Get all releases of economic data.](https://fred.stlouisfed.org/docs/api/fred/releases.html)
    pub fn releases() -> Releases { 
        serde_json::from_str(&response(
            "releases",
            Vec::new(),
        )).unwrap()
    }
    /// [Get release dates for all releases of economic data.](https://fred.stlouisfed.org/docs/api/fred/releases_dates.html)
    pub fn releases_dates() -> ReleaseDates { 
        serde_json::from_str(&response(
            "releases/dates",
            Vec::new(),
        )).unwrap()
    }
    /// [Get a release of economic data.](https://fred.stlouisfed.org/docs/api/fred/release.html)
    pub fn release(release_id: usize) -> Release { 
        serde_json::from_str(&response(
            "release",
            vec!(
                format!("release_id={}", release_id)
            ),
        )).unwrap()
    }
    /// [Get release dates for a release of economic data.](https://fred.stlouisfed.org/docs/api/fred/release_dates.html)
    pub fn release_dates(release_id: usize) -> ReleaseDates { 
        serde_json::from_str(&response(
            "release/dates",
            vec!(
                format!("release_id={}", release_id)
            ),
        )).unwrap()
    }
    /// [Get the series on a release of economic data.](https://fred.stlouisfed.org/docs/api/fred/release_series.html)
    pub fn release_series(release_id: usize) -> ReleaseSeries { 
        serde_json::from_str(&response(
            "release/series",
            vec!(
                format!("release_id={}", release_id)
            ),
        )).unwrap()
    }
    /// [Get the sources for a release of economic data.](https://fred.stlouisfed.org/docs/api/fred/release_sources.html)
    pub fn release_sources(release_id: usize) -> ReleaseSources { 
        serde_json::from_str(&response(
            "release/sources",
            vec!(
                format!("release_id={}", release_id)
            ),
        )).unwrap()
    }
    /// [Get the tags for a release.](https://fred.stlouisfed.org/docs/api/fred/release_tags.html)
    pub fn release_tags(release_id: usize) -> ReleaseTags { 
        serde_json::from_str(&response(
            "release/tags",
            vec!(
                format!("release_id={}", release_id)
            ),
        )).unwrap()
    }
    /// [Get the related tags for a release.](https://fred.stlouisfed.org/docs/api/fred/release_related_tags.html)
    pub fn release_related_tags(release_id: usize, tag_names: &str) -> ReleaseRelatedTags { 
        serde_json::from_str(&response(
            "release/related_tags",
            vec!(
                format!("release_id={}", release_id),
                format!("tag_names={}", tag_names),
            ),
        )).unwrap()
    }
    /// [Get the release tables for a given release.](https://fred.stlouisfed.org/docs/api/fred/release_tables.html)
    pub fn release_tables(release_id: usize) -> ReleaseTables { 
        serde_json::from_str(&response(
            "release/tables",
            vec!(
                format!("release_id={}", release_id)
            ),
        )).unwrap()
    }
    /// [Get an economic data series.](https://fred.stlouisfed.org/docs/api/fred/series.html)
    pub fn series(series_id: &str) -> Series { 
        serde_json::from_str(&response(
            "series",
            vec!(
                format!("series_id={}", series_id)
            ),
        )).unwrap()
    }
    /// [Get the categories for an economic data series.](https://fred.stlouisfed.org/docs/api/fred/series_categories.html)
    pub fn series_categories(series_id: &str) -> Categories { 
        serde_json::from_str(&response(
            "series/categories",
            vec!(
                format!("series_id={}", series_id)
            ),
        )).unwrap()
    }
    /// [Get the observations or data values for an economic data series.](https://fred.stlouisfed.org/docs/api/fred/series_observations.html)
    pub fn series_observations(series_id: &str) -> SeriesObservations { 
        serde_json::from_str(&response(
            "series/observations",
            vec!(
                format!("series_id={}", series_id)
            ),
        )).unwrap()
    }
    /// [Get the release for an economic data series.](https://fred.stlouisfed.org/docs/api/fred/series_release.html)
    pub fn series_release(series_id: &str) -> SeriesRelease { 
        serde_json::from_str(&response(
            "series/release",
            vec!(
                format!("series_id={}", series_id)
            ),
        )).unwrap()
    }
    /// [Get economic data series that match keywords.](https://fred.stlouisfed.org/docs/api/fred/series_search.html)
    pub fn series_search(search_text: &str) -> SeriesSearch { 
        serde_json::from_str(&response(
            "series/search",
            vec!(
                format!("search_text={}", search_text)
            ),
        )).unwrap()
    }
    /// [Get the tags for a series search.](https://fred.stlouisfed.org/docs/api/fred/series_search_tags.html)
    pub fn series_search_tags(series_search_text: &str) -> SeriesSearchTags { 
        serde_json::from_str(&response(
            "series/search/tags",
            vec!(
                format!("series_search_text={}", series_search_text)
            ),
        )).unwrap()
    }
    /// [Get the related tags for a series search.](https://fred.stlouisfed.org/docs/api/fred/series_search_related_tags.html)
    pub fn series_search_related_tags(series_search_text: &str, tag_names: &str) -> SeriesSearchRelatedTags { 
        serde_json::from_str(&response(
            "series/search/related_tags",
            vec!(
                format!("series_search_text={}", series_search_text),
                format!("tag_names={}", tag_names),
            ),
        )).unwrap()
    }
    /// [Get the tags for an economic data series.](https://fred.stlouisfed.org/docs/api/fred/series_tags.html)
    pub fn series_tags(series_id: &str) -> SeriesTags { 
        serde_json::from_str(&response(
            "series/tags",
            vec!(
                format!("series_id={}", series_id)
            ),
        )).unwrap()
    }
    /// [Get economic data series sorted by when observations were updated on the FRED® server.](https://fred.stlouisfed.org/docs/api/fred/series_updates.html)
    pub fn series_updates() -> SeriesUpdates { 
        serde_json::from_str(&response(
            "series/updates",
            Vec::new(),
        )).unwrap()
    }
    /// [Get the dates in history when a series' data values were revised or new data values were released.](https://fred.stlouisfed.org/docs/api/fred/series_vintagedates.html)
    pub fn series_vintagedates(series_id: &str) -> SeriesVintageDates { 
        serde_json::from_str(&response(
            "series/vintagedates",
            vec!(
                format!("series_id={}", series_id)
            ),
        )).unwrap()
    }
    /// [Get all sources of economic data.](https://fred.stlouisfed.org/docs/api/fred/sources.html)
    pub fn sources() -> Sources { 
        serde_json::from_str(&response(
            "sources",
            Vec::new(),
        )).unwrap()
    }
    /// [Get a source of economic data.](https://fred.stlouisfed.org/docs/api/fred/source.html)
    pub fn source(source_id: usize) -> ReleaseSources { 
        serde_json::from_str(&response(
            "source",
            vec!(
                format!("source_id={}", source_id)
            ),
        )).unwrap()
    }
    /// [Get the releases for a source.](https://fred.stlouisfed.org/docs/api/fred/source_releases.html)
    pub fn source_releases(source_id: usize) -> SourceReleases { 
        serde_json::from_str(&response(
            "source/releases",
            vec!(
                format!("source_id={}", source_id)
            ),
        )).unwrap()
    }
    /// [Get all tags, search for tags, or get tags by name.](https://fred.stlouisfed.org/docs/api/fred/tags.html)
    pub fn tags() -> Tags { 
        serde_json::from_str(&response(
            "tags",
            Vec::new(),
        )).unwrap()
    }
    /// [Get the related tags for one or more tags.](https://fred.stlouisfed.org/docs/api/fred/related_tags.html)
    pub fn related_tags(tag_names: &str) -> Tags { 
        serde_json::from_str(&response(
            "related_tags",
            vec!(
                format!("tag_names={}", tag_names)
            ),
        )).unwrap()
    }
    /// [Get the series matching tags.](https://fred.stlouisfed.org/docs/api/fred/tags_series.html)
    pub fn tags_series(tag_names: &str) -> TagsSeries { 
        serde_json::from_str(&response(
            "tags/series",
            vec!(
                format!("tag_names={}", tag_names)
            ),
        )).unwrap()
    }
}
fn response(url: &str, keyvals: Vec<String>) -> String {
    json(&request_str(url, keyvals))
}
fn json(req: &str) -> String {
    let json = reqwest::blocking::get(req)
        .unwrap()
        .text_with_charset("utf-8")
        .unwrap();
    fs::write("temp.json", &json).unwrap();
    json
}
fn request_str(url: &str, keyvals: Vec<String>) -> String {
    let mut s = format!(
        "https://api.stlouisfed.org/fred/{}?",
        url,
    );
    for kv in keyvals {
        s.push_str(&kv);
        s.push('&');
    };
    s.push_str(&format!(
        "api_key={}&file_type=json",
        env::var("FRED_API_KEY").unwrap(),
    ));
    s
}

File deletion: response.rs, response.rs

BF:BFD[4.2628] → [3.65:87]

BF:BFD[3.87] → [4.2643:2643]

BFD:BFD[4.2628] → [4.2629:2642]

BF:BFD[4.2642] → [4.2643:2643]

B:BD[4.2643] → [4.2644:2860]

∅:D[2.270] → [4.2860:2862]

B:BD[4.2860] → [4.2860:2862]

∅:D[2.272] → [4.2862:3198]

B:BD[4.2862] → [4.2862:3198]

∅:D[2.566] → [4.3198:4040]

B:BD[4.3198] → [4.3198:4040]

∅:D[2.949] → [4.4040:10034]

B:BD[4.4040] → [4.4040:10034]

∅:D[2.1209] → [4.10034:17351]

B:BD[4.10034] → [4.10034:17351]

∅:D[2.1581] → [4.17351:20181]

B:BD[4.17351] → [4.17351:20181]

B:BD[4.20181] → [2.1582:1709]

∅:D[2.1709] → [4.20213:20883]

B:BD[4.20213] → [4.20213:20883]

∅:D[2.1939] → [4.20883:21254]

B:BD[4.20883] → [4.20883:21254]

B:BD[4.20883] → [2.1710:1939]

B:BD[4.17351] → [2.1210:1581]

B:BD[4.10034] → [2.950:1209]

B:BD[4.4040] → [2.567:949]

B:BD[4.3198] → [2.273:566]

B:BD[4.2862] → [2.271:272]

B:BD[4.2860] → [2.0:270]

//! Javascript-like loosely typed data-structures based on FRED API.
use std::fmt;
use serde::{Deserialize};
#[derive(Debug, Deserialize)]
pub struct Categories {
    pub categories:                 Vec<Category>,
}
/// See [Fred docs: /fred/category](https://fred.stlouisfed.org/docs/api/fred/category.html).
///
#[derive(Debug, Deserialize)]
pub struct Category {
    pub id:                         usize,
    pub name:                       String,
    pub parent_id:                  usize,
    pub notes:                      Option<String>,
}
/// See [Fred docs: /fred/category/children](https://fred.stlouisfed.org/docs/api/fred/category_children.html).
#[derive(Debug, Deserialize)]
pub struct CategoryChildren {
    pub categories:                 Vec<Category>,
}
/// See [Fred docs: /fred/category/related](https://fred.stlouisfed.org/docs/api/fred/category_related.html).
#[derive(Debug, Deserialize)]
pub struct CategoryRelated {
    categories:                     Vec<Category>,
}
/// See Fred docs
#[derive(Debug, Deserialize)]
pub struct CategorySeries {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub count:                      isize,
    pub offset:                     isize,
    pub limit:                      isize,
    pub seriess:                    Vec<SeriesItem>,
}
/// See [Fred docs: /fred/category/tags](https://fred.stlouisfed.org/docs/api/fred/category_tags.html).
#[derive(Debug, Deserialize)]
pub struct CategoryTags {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub sort_order:                 String,
    pub count:                      isize,
    pub offset:                     isize,
    pub limit:                      isize,
    pub tags:                       Vec<Tag>,
}
#[derive(Debug, Deserialize)]
pub struct Tag {
    pub name:                       String,
    pub group_id:                   String,
    pub notes:                      Option<String>,
    pub created:                    String,
    pub popularity:                 isize,
    pub series_count:               isize,
}
impl fmt::Display for Tag {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f,
            "name: {}\nnotes: {:?}\nseries_count: {}",
            self.name,
            self.notes,
            self.series_count
        )
    }
}
/// See [Fred docs: /fred/category/related_tags](https://fred.stlouisfed.org/docs/api/fred/category_related_tags.html).
#[derive(Debug, Deserialize)]
pub struct CategoryRelatedTags {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub sort_order:                 String,
    pub count:                      isize,
    pub offset:                     isize,
    pub limit:                      isize,
    pub tags:                       Vec<Tag>,
}
/// See [Fred docs: /fred/releases](https://fred.stlouisfed.org/docs/api/fred/releases.html).
#[derive(Debug, Deserialize)]
pub struct Releases {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub sort_order:                 String,
    pub count:                      isize,
    pub offset:                     isize,
    pub limit:                      isize,
    pub releases:                   Vec<ReleaseItem>,
}
/// See [Fred docs: /fred/release](https://fred.stlouisfed.org/docs/api/fred/release.html).
#[derive(Debug, Deserialize)]
pub struct Release {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub releases:                   Vec<ReleaseItem>,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseItem {
    pub id:                         isize,
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub name:                       String,
    pub press_release:              bool,
    pub link:                       Option<String>,
}
/// See [Fred docs: /fred/release/dates](https://fred.stlouisfed.org/docs/api/fred/release_dates.html).
#[derive(Debug, Deserialize)]
pub struct ReleasesDates {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub sort_order:                 String,
    pub count:                      isize,
    pub offset:                     isize,
    pub limit:                      isize,
    pub release_dates:              Vec<ReleaseDate>,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseDates {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub sort_order:                 String,
    pub count:                      isize,
    pub offset:                     isize,
    pub limit:                      isize,
    pub release_dates:              Vec<ReleaseDateItem>,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseDateItem {
    pub release_id:                 isize,
    pub date:                       String,
}
#[derive(Debug, Deserialize)]
pub struct ReleaseDate {
    pub release_id:                 isize,
    pub release_name:               String,
    pub date:                       String,
}
/// See [Fred docs: /fred/release/series](https://fred.stlouisfed.org/docs/api/fred/release_series.html).
#[derive(Debug, Deserialize)]
pub struct ReleaseSeries {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub sort_order:                 String,
    pub count:                      isize,
    pub offset:                     isize,
    pub limit:                      isize,
    pub seriess:                    Vec<SeriesItem>,
}
/// See [Fred docs: /fred/release/sources](https://fred.stlouisfed.org/docs/api/fred/release_sources.html).
#[derive(Debug, Deserialize)]
pub struct ReleaseSources {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub sources:                    Vec<SourceItem>,
}
#[derive(Debug, Deserialize)]
pub struct SourceItem {
    pub id:                         isize,
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub name:                       String,
    pub link:                       Option<String>,
}
/// See [Fred docs: /fred/release/tags](https://fred.stlouisfed.org/docs/api/fred/release_tags.html).
#[derive(Debug, Deserialize)]
pub struct ReleaseTags {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub sort_order:                 String,
    pub count:                      isize,
    pub offset:                     isize,
    pub limit:                      isize,
    pub tags:                       Vec<TagItem>,
}
#[derive(Debug, Deserialize)]
pub struct TagItem {
    pub name:                       String,
    pub group_id:                   String,
    pub notes:                      Option<String>,
    pub created:                    String,
    pub popularity:                 isize,
    pub series_count:               isize,
}
/// See [Fred docs: /fred/release/related_tags](https://fred.stlouisfed.org/docs/api/fred/release_related_tags.html).
#[derive(Debug, Deserialize)]
pub struct ReleaseRelatedTags {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub sort_order:                 String,
    pub count:                      isize,
    pub offset:                     isize,
    pub limit:                      isize,
    pub tags:                       Vec<TagItem>,
}
/// See [Fred docs: /fred/release/related_tags](https://fred.stlouisfed.org/docs/api/fred/release_related_tags.html).
#[derive(Debug, Deserialize)]
pub struct ReleaseTables {
    pub name:                       String,
    pub element_id:                 isize,
    pub release_id:                 String,
    pub elements:                   Vec<ReleaseKeyVal>,
}
/// See [Fred docs: /fred/release/related_tags](https://fred.stlouisfed.org/docs/api/fred/release_related_tags.html).
#[derive(Debug, Deserialize)]
pub struct ReleaseKeyVal {
    pub key:                        isize,
    pub value:                      ReleaseElement,
}
/// See [Fred docs: /fred/release/related_tags](https://fred.stlouisfed.org/docs/api/fred/release_related_tags.html).
#[derive(Debug, Deserialize)]
pub struct ReleaseElement {
    pub element_id:                 isize,
    pub release_id:                 String,
    pub series_id:                  String,
    pub parent_id:                  String,
    pub line:                       String,
    #[serde(rename = "type")] 
    pub ty:                         String,
    pub name:                       String,
    pub level:                      String,
    pub children:                   Vec<ReleaseElement>,
}
#[derive(Debug, Deserialize)]
pub struct Series {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub seriess:                    Vec<SeriesItem>,
}
impl fmt::Display for Series {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut s = format!(
            "{}-{}\n",
            self.realtime_start,
            self.realtime_end,
        );
        for item in &self.seriess {
            s.push_str(&item.to_string())
        };
        write!(f, "{}", s)
    }
}
#[derive(Debug, Deserialize)]
pub struct SeriesItem {
    pub id:                         String,
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub title:                      String,
    pub observation_start:          String,
    pub observation_end:            String,
    pub frequency:                  String,
    pub units:                      String,
    pub units_short:                String,
    pub seasonal_adjustment:        String,
    pub seasonal_adjustment_short:  String,
    pub last_updated:               String,
    pub popularity:                 isize,
    pub group_popularity:           Option<isize>,
    pub notes:                      Option<String>,
}
impl fmt::Display for SeriesItem {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(
            f,
            "{}\n{}\n{}-{}\n{}\n{}",
            self.id,
            self.title,
            self.observation_start,
            self.observation_end,
            self.frequency,
            self.seasonal_adjustment,
        )
    }
}
/// See [Fred docs: /fred/series/categories](https://fred.stlouisfed.org/docs/api/fred/series_categories.html).
#[derive(Debug, Deserialize)]
pub struct SeriesCategories {
    pub categories:                 Vec<CategoryItem>,
}
#[derive(Debug, Deserialize)]
pub struct CategoryItem {
    pub id:                         String,
    pub name:                       String,
    pub parent_id:                  isize,
}
/// See [Fred docs: /fred/series/observations](https://fred.stlouisfed.org/docs/api/fred/series_observations.html).
#[derive(Debug, Deserialize)]
pub struct SeriesObservations {
    pub realtime_start:             String, 
    pub realtime_end:               String, 
    pub observation_start:          String, 
    pub observation_end:            String, 
    pub units:                      String, 
    pub output_type:                isize, 
    pub file_type:                  String, 
    pub order_by:                   String, 
    pub sort_order:                 String, 
    pub count:                      isize, 
    pub offset:                     isize, 
    pub limit:                      isize, 
    pub observations:               Vec<Observation>,
}
/// See [Fred docs: /fred/series/observations](https://fred.stlouisfed.org/docs/api/fred/series_observations.html).
#[derive(Debug, Deserialize)]
pub struct Observation {
    pub realtime_start:             String, 
    pub realtime_end:               String, 
    pub date:                       String, 
    pub value:                      String, 
}
/// See [Fred docs: /fred/series/release](https://fred.stlouisfed.org/docs/api/fred/series_release.html).
#[derive(Debug, Deserialize)]
pub struct SeriesRelease {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub releases:                   Vec<ReleaseItem>,
}
/// See [Fred docs: /fred/series/search](https://fred.stlouisfed.org/docs/api/fred/series_search.html).
#[derive(Debug, Deserialize)]
pub struct SeriesSearch {
    pub realtime_start:             String, 
    pub realtime_end:               String, 
    pub order_by:                   String, 
    pub sort_order:                 String, 
    pub count:                      isize, 
    pub offset:                     isize, 
    pub limit:                      isize, 
    pub seriess:                    Vec<SeriesItem>,
}
#[derive(Debug, Deserialize)]
pub struct SeriesSearchTags {
    pub realtime_start:             String, 
    pub realtime_end:               String, 
    pub order_by:                   String, 
    pub sort_order:                 String, 
    pub count:                      isize, 
    pub offset:                     isize, 
    pub limit:                      isize, 
    pub tags:                       Vec<TagItem>,
}
/// See [Fred docs: /fred/series/search/related_tags](https://fred.stlouisfed.org/docs/api/fred/series_search_related_tags.html).
#[derive(Debug, Deserialize)]
pub struct SeriesSearchRelatedTags {
    pub realtime_start:             String, 
    pub realtime_end:               String, 
    pub order_by:                   String, 
    pub sort_order:                 String, 
    pub count:                      isize, 
    pub offset:                     isize, 
    pub limit:                      isize, 
    pub tags:                       Vec<TagItem>,
}
/// See [Fred docs: /fred/series/tags](https://fred.stlouisfed.org/docs/api/fred/series_tags.html).
#[derive(Debug, Deserialize)]
pub struct SeriesTags {
    pub realtime_start:             String, 
    pub realtime_end:               String, 
    pub order_by:                   String, 
    pub sort_order:                 String, 
    pub count:                      isize, 
    pub offset:                     isize, 
    pub limit:                      isize, 
    pub tags:                       Vec<TagItem>,
}
/// See [Fred docs: /fred/series/updates](https://fred.stlouisfed.org/docs/api/fred/series_updates.html).
#[derive(Debug, Deserialize)]
pub struct SeriesUpdates {
    pub realtime_start:             String, 
    pub realtime_end:               String, 
    pub filter_variable:            String, 
    pub filter_value:               String, 
    pub order_by:                   String, 
    pub sort_order:                 String, 
    pub count:                      isize, 
    pub offset:                     isize, 
    pub limit:                      isize, 
    pub seriess:                    Vec<SeriesItem>,
}
/// See [Fred docs: /fred/series/vintage_dates](https://fred.stlouisfed.org/docs/api/fred/series_vintagedates.html).
#[derive(Debug, Deserialize)]
pub struct SeriesVintageDates {
    pub realtime_start:             String, 
    pub realtime_end:               String, 
    pub order_by:                   String, 
    pub sort_order:                 String, 
    pub count:                      isize, 
    pub offset:                     isize, 
    pub limit:                      isize, 
    pub vintage_dates:              Vec<String>,
}
/// See [Fred docs: /fred/sources](https://fred.stlouisfed.org/docs/api/fred/sources.html).
#[derive(Debug, Deserialize)]
pub struct Sources {
    pub realtime_start:             String, 
    pub realtime_end:               String, 
    pub order_by:                   String, 
    pub sort_order:                 String, 
    pub count:                      isize, 
    pub offset:                     isize,
    pub limit:                      isize, 
    pub sources:                    Vec<SourceItem>,
}
/// See [Fred docs: /fred/source/releases](https://fred.stlouisfed.org/docs/api/fred/source_releases.html).
#[derive(Debug, Deserialize)]
pub struct SourceReleases {
    pub realtime_start:             String, 
    pub realtime_end:               String, 
    pub order_by:                   String, 
    pub sort_order:                 String, 
    pub count:                      isize, 
    pub offset:                     isize, 
    pub limit:                      isize,
    pub releases:                   Vec<ReleaseItem>,
}
/// See [Fred docs: /fred/tags](https://fred.stlouisfed.org/docs/api/fred/tags.html).
#[derive(Debug, Deserialize)]
pub struct Tags {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub sort_order:                 String,
    pub count:                      isize,
    pub offset:                     isize,
    pub limit:                      isize,
    pub tags:                       Vec<Tag>,
}
impl fmt::Display for Tags {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut tags = String::new();
        for (i, tag) in self.tags.iter().enumerate() {
            tags.push_str(&i.to_string());
            tags.push('\n');
            tags.push_str(&tag.to_string());
            tags.push('\n');
            tags.push('\n');
        };
        write!(f, "{}", tags)
    }
}
/// See [Fred docs: /fred/tags/series](https://fred.stlouisfed.org/docs/api/fred/tags_series.html).
#[derive(Debug, Deserialize)]
pub struct TagsSeries {
    pub realtime_start:             String,
    pub realtime_end:               String,
    pub order_by:                   String,
    pub sort_order:                 String,
    pub count:                      isize,
    pub offset:                     isize, 
    pub limit:                      isize, 
    pub seriess:                    Vec<SeriesItem>,
}
impl fmt::Display for TagsSeries {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut series = String::new();
        for (i, s) in self.seriess.iter().enumerate() {
            series.push_str(&format!("{}\n", i));
            series.push_str(&s.to_string());
            series.push('\n');
        };
        write!(f, "{}", series)
    }
}
impl TagsSeries {
    pub fn series_titles(&self) -> String {
        let mut s = String::new();
        for series in &self.seriess {
            s.push_str(&series.title);
            s.push('\n');
        }
        s
    }
}
}
impl fmt::Display for SeriesTags {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut s = String::new();
        for (i, tags) in self.tags.iter().enumerate() {
            s.push_str(&i.to_string());
            s.push('\n');
            s.push_str(&tags.to_string());
            s.push('\n');
        };
        write!(f, "{}", s)
    }
impl fmt::Display for TagItem {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f,
            "name: {}\ngroup_id: {}\nnotes: {:?}\n",
            self.name,
            self.group_id,
            self.notes,
        )
    }
}
impl fmt::Display for CategorySeries {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut s = String::new();
        for (i, series) in self.seriess.iter().enumerate() {
            s.push_str(&i.to_string());
            s.push('\n');
            s.push_str(&series.to_string());
            s.push('\n');
        };
        write!(f, "{}", s)
    }
}
impl fmt::Display for Category {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f,
            "id: {}\nname: {}\nparent_id: {}\nnotes: {:?}\n",
            self.id,
            self.name,
            self.parent_id,
            self.notes,
        )
    }
}
}
impl fmt::Display for Categories {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut s = String::new();
        for category in &self.categories {
            s.push_str(&category.to_string());
        };
        write!(f, "{}", s)
    }

File deletion: Cargo.toml.AZQVIGSM6OJHM, Cargo.toml

BF:BFD[1.0] → [3.6636:6671]

BF:BFD[3.6671] → [4.33361:33361]

BFD:BFD[1.0] → [4.33348:33360]

BF:BFD[4.33360] → [4.33361:33361]

B:BD[4.33361] → [4.33362:33767]

[package]
name = "fred_api"
version = "0.1.0"
authors = ["Eric Findlay <e.findlay@protonmail.ch>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
rand = "0.8.0"
reqwest = { version = "0.10", features = ["blocking", "json"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0.60"
[lib]
doctest = false

Deletion in src/ts.rs at line 3 [6.7119]
∅:D[5.1023] → [6.7581:7612]
B:BD[6.7581] → [6.7581:7612]
```
use std::collections::HashMap;
```
Insertion in src/ts.rs at line 6 [6.7119]
[7.46]
[6.7664]
```
use std::fmt;
```

Replacement in src/ts.rs at line 10 [6.7119]

B:BD[6.7678] → [8.0:80]

use serde::{
    Serialize,
    Serializer,
};
use serde::ser::SerializeStruct;

[6.7678]

[6.7700]

// use serde::{
//     Serialize,
//     Serializer,
// };
// use serde::ser::SerializeStruct;

Replacement in src/ts.rs at line 21 [6.7119]

B:BD[6.7846] → [6.7846:7888]

use time_series::{
    RegularTimeSeries,

[6.7846]

[6.7904]

use keytree::serialize::{
    KeyTreeString,
    IntoKeyTree,

Insertion in src/ts.rs at line 25 [6.7119]
[6.7907]
[6.7907]
```
// use time_series::{
//     RegularTimeSeries,
// };
```
Replacement in src/ts.rs at line 59 [6.7119]
B:BD[5.5320] → [5.5320:5352]
```
pub struct Spec(Vec<PageSpec>);
```
[5.5320]
[5.5352]
```
pub struct Spec(pub Vec<PageSpec>);
```
Deletion in src/ts.rs at line 82 [6.7119]
B:BD[5.7648] → [5.7648:7654]
∅:D[5.7654] → [6.9207:9208]
B:BD[6.9207] → [6.9207:9208]
B:BD[6.9208] → [5.7655:7721]
∅:D[5.7721] → [6.9251:9252]
B:BD[6.9251] → [6.9251:9252]
B:BD[6.9252] → [5.7722:7811]
```
    }
    pub (crate) fn new() -> Self {
        Spec(Vec::new())
    }
    pub (crate) fn push(&mut self, page_spec: PageSpec) {
        self.0.push(page_spec)
```

Insertion in src/ts.rs at line 93 [6.7119]

[6.9861]

[5.7962]

impl IntoKeyTree for Spec {
    fn keytree(&self) -> KeyTreeString {
        let mut kt = KeyTreeString::new();
        kt.push_key(0, "ts_spec");
        for page_spec in &self.0 {
            kt.push_keytree(1, page_spec.keytree());
        }
        kt
    }
}

Replacement in src/ts.rs at line 123 [6.7119]
B:BD[5.8473] → [5.8473:8547]
B:BD[5.8547] → [3.354:387]
∅:D[3.387] → [5.8547:8581]
B:BD[5.8547] → [5.8547:8581]
∅:D[9.6562] → [6.10060:10062]
∅:D[5.8581] → [6.10060:10062]
B:BD[6.10060] → [6.10060:10062]
B:BD[6.10084] → [7.2795:2796]
B:BD[7.2796] → [5.8582:8598]
∅:D[5.8598] → [6.10213:10214]
B:BD[6.10213] → [6.10213:10214]
```
    country:    Country,
    data_type:  DataType,
    index:      usize,
    series:     Vec<SeriesSpec>,
    graphics:   Vec<GraphicSpec>,
}
impl PageSpec {
```
[5.8473]
[5.8599]
```
    ///
    pub country:    Country,
    ///
    pub data_type:  DataType,
```

Replacement in src/ts.rs at line 128 [6.7119]

B:BD[5.8607] → [5.8607:8709]

B:BD[5.8709] → [3.388:425]

∅:D[3.425] → [5.8709:8762]

B:BD[5.8709] → [5.8709:8762]

B:BD[5.8762] → [3.426:491]

∅:D[3.491] → [7.2880:2886]

∅:D[9.6688] → [7.2880:2886]

∅:D[5.8819] → [7.2880:2886]

B:BD[6.10298] → [7.2880:2886]

    pub fn new(
        country:    Country,
        data_type:  DataType,
        index:      usize,
        series:     Vec<SeriesSpec>,
        graphics:   Vec<GraphicSpec>) -> Self
    { 
        PageSpec { country, data_type, index, series, graphics }
    }

[5.8607]

[5.8820]

    pub index:      usize,
    ///
    pub series:     Vec<SeriesSpec>,
    ///
    pub graphics:   Vec<GraphicSpec>,

Insertion in src/ts.rs at line 148 [6.7119]

[7.3483]

[3.551]

    }
}
impl IntoKeyTree for PageSpec {
    fn keytree(&self) -> KeyTreeString {
        let mut kt = KeyTreeString::new();
        kt.push_key(0, "page");
        kt.push_value(1, "country", self.country);
        kt.push_value(1, "data_type", self.data_type);
        kt.push_value(1, "index", self.index);
        for series in &self.series {
            kt.push_keytree(1, series.keytree());
        }
        for graphic in &self.graphics {
            kt.push_keytree(1, graphic.keytree());
        }
        kt

Insertion in src/ts.rs at line 186 [6.7119]

[3.1107]

        }
    }
}
impl fmt::Display for TextSpec {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TextSpec::Link => write!(f, "link"),
            TextSpec::Meta => write!(f, "meta"),
            TextSpec::None => write!(f, "none"),

Insertion in src/ts.rs at line 200 [6.7119]

[6.10307]

[5.9224]

impl IntoKeyTree for TextSpec {
    fn keytree(&self) -> KeyTreeString {
        let mut kt = KeyTreeString::new();
        match self {
            TextSpec::Link => kt.push_value(0, "text", "link"),
            TextSpec::Meta => kt.push_value(0, "text", "meta"),
            TextSpec::None => {},
        }
        kt
    }
}

Replacement in src/ts.rs at line 223 [6.7119]

B:BD[5.9473] → [3.1118:1150]

∅:D[3.1150] → [5.9473:9502]

B:BD[5.9473] → [5.9473:9502]

B:BD[5.9502] → [3.1151:1237]

∅:D[3.1237] → [5.9541:9543]

B:BD[5.9541] → [5.9541:9543]

∅:D[5.9543] → [6.10428:10429]

B:BD[6.10428] → [6.10428:10429]

B:BD[6.10429] → [5.9544:9563]

B:BD[5.9563] → [3.1238:1275]

∅:D[3.1275] → [5.9598:9620]

B:BD[5.9598] → [5.9598:9620]

B:BD[5.9620] → [3.1276:1448]

∅:D[10.1211] → [6.10698:10708]

∅:D[3.1448] → [6.10698:10708]

∅:D[9.6972] → [6.10698:10708]

∅:D[5.9679] → [6.10698:10708]

B:BD[6.10698] → [6.10698:10708]

B:BD[6.10708] → [5.9680:9687]

B:BD[5.9687] → [3.1449:1818]

    title:      Option<String>,
    height:     Option<f32>,
    series_id:  Vec<SeriesId>,
    fid:        Vec<String>,
    text:       TextSpec,
}
impl GraphicSpec {
    pub (crate) fn empty() -> Self {
        GraphicSpec {
            title:      None,
            height:     None,
            series_id:  Vec::new(),
            fid:        Vec::new(),
            text:       TextSpec::None,
        }
    }
    // pub (crate) fn push(
    //     &mut self,
    //     title:          Option<Title>,
    //     height:         Option<f32>,
    //     transform_spec: Vec<TransformSpec>)
    // {
    //     let graph_spec = GraphSpec {
    //         title,
    //         height,
    //         transform_spec,
    //     };
    //     self.seriess.push(series_spec)
    // }

[5.9473]

[6.10725]

    ///
    pub title:      Option<String>,
    ///
    pub height:     Option<f32>,
    ///
    pub series_id:  Vec<SeriesId>,
    ///
    pub fid:        Vec<String>,
    ///
    pub text_spec:  TextSpec,

Replacement in src/ts.rs at line 245 [6.7119]

B:BD[3.2116] → [3.2116:2178]

                text:           self.value("graphic::text")?,

[3.2116]

[9.7030]

                text_spec:      self.value("graphic::text")?,

Insertion in src/ts.rs at line 250 [6.7119]

[9.7062]


impl IntoKeyTree for GraphicSpec {
    fn keytree(&self) -> KeyTreeString {
        let mut kt = KeyTreeString::new();
        kt.push_key(0, "graphic" );

Insertion in src/ts.rs at line 256 [6.7119]

[9.7063]

[5.10062]

        if let Some(title) = &self.title {
            kt.push_value(1, "title", title);
        }
        if let Some(h) = &self.height {
            kt.push_value(1, "height", h);
        }
        for series_id in &self.series_id {
            kt.push_value(1, "series_id", series_id);
        }
        for fid in &self.fid {
            kt.push_value(1, "fid", fid)
        }
        kt.push_value(1, "text", &self.text_spec);
        kt
    }
}

Replacement in src/ts.rs at line 287 [6.7119]

∅:D[5.10283] → [9.7219:7271]

B:BD[9.7219] → [9.7219:7271]

B:BD[9.7271] → [3.2197:2285]

∅:D[3.2285] → [9.7271:7274]

B:BD[9.7271] → [9.7271:7274]

B:BD[9.7274] → [5.10284:10302]

B:BD[5.10302] → [3.2286:2287]

∅:D[3.2287] → [5.10302:10311]

B:BD[5.10302] → [5.10302:10311]

B:BD[5.10311] → [3.2288:2481]

∅:D[3.2481] → [5.10312:10333]

B:BD[9.7394] → [5.10312:10333]

∅:D[5.10333] → [9.7417:7463]

B:BD[9.7417] → [9.7417:7463]

B:BD[9.7463] → [3.2482:2547]

∅:D[3.2547] → [9.7463:7479]

B:BD[9.7463] → [9.7463:7479]

    data_type:  DataType,
    series_id:  SeriesId,
    date_range: DateRange,
    transforms: Vec<Transform>,
    fid:        Option<FID>,
}
impl SeriesSpec {
    /// 
    pub fn new(
        data_type:  DataType,
        series_id:  SeriesId,
        date_range: DateRange,
        transforms: Vec<Transform>, 
        fid:        Option<FID>,
    ) -> Self {
        SeriesSpec {
            data_type,
            series_id,
            date_range,
            transforms,
            fid,
        }
    }

[5.10283]

[9.7479]

    ///
    pub data_type:  DataType,
    ///
    pub series_id:  SeriesId,
    ///
    pub date_range: DateRange,
    ///
    pub transforms: Vec<Transform>,
    ///
    pub fid:        Option<FID>,

Insertion in src/ts.rs at line 321 [6.7119]

[3.3051]


impl IntoKeyTree for SeriesSpec {
    fn keytree(&self) -> KeyTreeString {
        let mut kt = KeyTreeString::new();
        kt.push_key(0, "series");
        kt.push_value(1, "data_type", &self.data_type);
        kt.push_value(1, "series_id", &self.series_id);

Insertion in src/ts.rs at line 330 [6.7119]

[3.3052]

        if let Some(first_date) = self.date_range.first_date() {
            kt.push_value(1, "first_date", first_date);
        }
        if let Some(last_date) = self.date_range.last_date() {
            kt.push_value(1, "last_date", last_date);
        };
        for f in &self.transforms {
            kt.push_value(1, "f", f); 
        }
        if let Some(fid) = &self.fid {
            kt.push_value(1, "fid", fid);
        }
        kt
    }
}

Insertion in src/ts.rs at line 372 [6.7119]

[3.3750]


impl fmt::Display for Transform {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Transform::ToMonthly => write!(f, "to_monthly"),
            Transform::ToQuarterly => write!(f, "to_quarterly"),
            Transform::YearOnYear => write!(f, "yoy"),
        }
    }
}

Insertion in src/ts.rs at line 411 [6.7119]

[3.4427]


impl fmt::Display for FID {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

Replacement in src/main.rs at line 45 [12.10]

B:BD[5.11132] → [11.3089:3168]

        let _data_spec =  DataSpec::from_file("source_data.keytree").unwrap();

[5.11132]

[5.11210]

        let data_spec =  DataSpec::from_file("source_data.keytree").unwrap();

Replacement in src/main.rs at line 50 [12.10]

B:BD[13.10088] → [5.11281:11347]

        // println!("{}", data_spec.generic_ts_spec().keytree());

[13.10088]

[5.11347]

        println!("{}", data_spec.generic_ts_spec().keytree());

Insertion in src/lib.rs at line 206 [15.16]
[14.2424]
[5.12294]
```
use crate::ts::{
    TextSpec,
};
```

Insertion in src/lib.rs at line 239 [15.16]

[14.2860]

    }
}
impl fmt::Display for MonthlyDate {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}-{}-01", self.0.year(), self.0.month())

Replacement in src/lib.rs at line 458 [15.16]

B:BD[10.4927] → [3.5423:5521]

    // /// Build a generic `Spec` from `Self`.
    // pub fn generic_ts_spec(&self) -> ts::Spec {

[10.4927]

[10.5019]

    /// Build a generic `Spec` from `Self`.
    pub fn generic_ts_spec(&self) -> ts::Spec {

Replacement in src/lib.rs at line 461 [15.16]

B:BD[10.5020] → [3.5522:5568]

    //     let mut ts_spec = ts::Spec::new();

[10.5020]

[10.5061]

        let mut spec = ts::Spec(Vec::new());

Replacement in src/lib.rs at line 463 [15.16]

B:BD[10.5062] → [3.5569:5642]

    //     for ((data_type, country), series_specs) in self.map.iter() {

[10.5062]

[10.5132]

        for ((data_type, country), series_specs) in self.map.iter() {

Replacement in src/lib.rs at line 465 [15.16]

B:BD[10.5133] → [3.5643:5707]

    //         let mut graphic_spec = ts::GraphicSpec::empty();

[10.5133]

[10.5193]

            let mut page_spec = ts::PageSpec {
                country:    *country,
                data_type:  *data_type,
                index:      0,
                series:     Vec::new(),
                graphics:   Vec::new(),
            };

Replacement in src/lib.rs at line 473 [15.16]

B:BD[10.5194] → [3.5708:5797]

    //         let series_id = series_spec.series_id;
    //         let f = Vec::new();

[10.5194]

[3.5797]

            let mut collated_graphic = ts::GraphicSpec {
                title:      None,
                height:     None,
                series_id:  Vec::new(),
                fid:        Vec::new(),
                text_spec:  TextSpec::Link,
            };

Replacement in src/lib.rs at line 481 [15.16]

B:BD[3.5798] → [3.5798:6204]

    //         for series_spec in series_specs {
    //             let series_spec = ts::SeriesSpec::new(
    //                 series_spec.data_type,
    //                 series_id,
    //                 DateRange::new(&None, &None),
    //                 f, 
    //                 FID::new(series_id, f), 
    //             );
    //             graphic_spec.push(series_spec);
    //         };

[3.5798]

[10.5477]

            let mut single_graphics = Vec::new();

Replacement in src/lib.rs at line 483 [15.16]

B:BD[10.5478] → [3.6205:6425]

    //         let page_spec = ts::PageSpec::new(
    //             *country,
    //             *data_type,
    //             0,
    //             Vec::new(),
    //             vec!(graphic_spec),
    //         );

[10.5478]

[5.14041]

            for series_spec in series_specs {
                let ts_series_spec = ts::SeriesSpec {
                    data_type:      series_spec.data_type,
                    series_id:      series_spec.series_id.clone(),
                    date_range:     DateRange::new(&None, &None),
                    transforms:     Vec::new(),
                    fid:            None,
                };
                // Series
                page_spec.series.push(ts_series_spec);
                // Single-series graphics
                let single_series_graphic = ts::GraphicSpec {
                    title:      None,
                    height:     None,
                    series_id:  vec!(series_spec.series_id.clone()), 
                    fid:        Vec::new(),
                    text_spec:  TextSpec::Meta,
                };
                single_graphics.push(single_series_graphic);
                // Collated graphic
                collated_graphic.series_id.push(series_spec.series_id.clone());
            };
            let mut graphics = vec!(collated_graphic);
            graphics.append(&mut single_graphics);
            page_spec.graphics = graphics;

Replacement in src/lib.rs at line 518 [15.16]

B:BD[5.14042] → [3.6426:6505]

    //         spec.push(ts_page_spec); 
    //     }
    //     spec
    // }

[5.14042]

[10.5698]

            spec.0.push(page_spec); 
        }
        spec
    }