Enum Interval 

pub enum Interval {
    Undefined(String),
    Min1,
    Min5,
    Min15,
    Min30,
    Hour1,
    Hour2,
    Hour4,
    Day1,
    Week1,
    Month1,
}

Variants

Undefined(String)

Min1

Min5

Min15

Min30

Hour1

Hour2

Hour4

Day1

Week1

Month1

Implementations

impl Interval

pub fn undefined(s: &str) -> Interval

Create an undefined interval.

pub fn parse(s: &str) -> Result<Interval>

Parses an interval from a string.

pub fn parse_undefined(s: &str) -> Interval

Parses an interval from a string, or return the undefined interval if it fails.

Examples found in repository

examples/tradingview_get.rs (line 154)

async fn main() -> Result<()> {
    let opts = Opts::parse();
    match opts.subcmd {
        SubCommand::Search(args) => {
            // Parse arguments
            let screener = args.screener;
            let exchanges = args.exchanges;
            let types = args.types;
            let name_filter = args.name;
            // Prepare extra fields if specified
            let extra_fields: Vec<FieldWithInterval> = args
                .fields
                .into_iter()
                .map(|x| FieldWithInterval::parse_undefined(&x))
                .collect();

            // Initialize TradingView client and search symbols with given parameters
            let tv = TradingView::new(&screener, "");
            let values = tv
                .search_symbols(&exchanges, &types, name_filter, &extra_fields)
                .await
                .context("search symbols error")?;

            // Prepare fields to be printed
            let fields = [
                Field::Exchange,
                Field::Name,
                Field::Type,
                Field::Description,
            ]
            .into_iter()
            .map(|x| x.with_interval(&Interval::default()))
            .chain(extra_fields.into_iter())
            .collect::<Vec<_>>();

            // Assemble data rows for output
            let mut table: Vec<Vec<String>> = vec![];
            for vals in values {
                let mut row = vec![];
                for field in fields.iter() {
                    let val = vals
                        .values()
                        .get(&field)
                        .map_or("".into(), |x| x.to_string());
                    row.push(val);
                }
                table.push(row);
            }

            // Print csv header
            println!(
                "{}",
                fields
                    .iter()
                    .map(|x| x.to_string())
                    .collect::<Vec<_>>()
                    .join(",")
            );
            // Print csv data rows
            for vals in table {
                println!("{}", vals.join(","));
            }
        }
        SubCommand::Scan(args) => {
            // Parse arguments
            let screener = args.screener;
            let exchange = args.exchange;
            let interval = Interval::parse_undefined(&args.default_interval);
            let symbols = args.symbols;
            // Prepare fields with default intervals if not specified
            let fields = args
                .fields
                .iter()
                .map(|x| FieldWithInterval::parse_undefined_with_default_interval(x, &interval))
                .collect::<Vec<_>>();

            // Initialize TradingView client and retrieve data for specified symbols and fields
            let tv = TradingView::new(&screener, exchange);
            let symbols = tv
                .scan_symbols(&symbols, &fields)
                .await
                .context("scan symbols error")?;

            // Assemble data rows for output
            let mut table: Vec<Vec<String>> = vec![];
            for vals in symbols {
                let mut row = vec![format!("\"{}\"", vals.symbol())];
                for field in fields.iter() {
                    let val = vals
                        .values()
                        .get(&field)
                        .map_or("".into(), |x| x.to_string());
                    row.push(val);
                }
                table.push(row);
            }

            // Print csv header
            println!(
                "symbol,{}",
                fields
                    .iter()
                    .map(|x| x.to_string())
                    .collect::<Vec<_>>()
                    .join(",")
            );
            // Print csv data rows
            for vals in table {
                println!("{}", vals.join(","));
            }
        }
        SubCommand::Get(args) => {
            // Parse arguments
            let screener = args.screener;
            let exchange = args.exchange;
            let interval = Interval::parse_undefined(&args.interval);
            let symbol = args.symbol;
            // Prepare fields with default intervals if not specified
            let fields = args
                .fields
                .iter()
                .map(|x| FieldWithInterval::parse_undefined_with_default_interval(x, &interval))
                .collect::<Vec<_>>();

            // Initialize TradingView client and retrieve data for specified symbol and fields
            let tv = TradingView::new(&screener, exchange);
            let symbol = tv
                .get_symbol_fields_with_interval(&symbol, &fields)
                .await
                .context("Failed to retrieve symbol fields")?;

            // Collect key-value pairs for output, including screener, symbol, interval, and field data
            let mut values: Vec<(String, Value)> = Vec::new();
            values.extend(vec![
                ("screener".to_string(), json!(screener.to_string())),
                ("symbol".to_string(), json!(symbol.symbol().to_string())),
                ("interval".to_string(), json!(interval.to_string())),
            ]);
            for field in &fields {
                if let Some(val) = symbol.values().get(field) {
                    values.push((field.to_string(), val.clone()));
                }
            }

            // Output data, formatted as JSON if specified, else as plain key-value pairs
            if args.json {
                println!(
                    "{}",
                    serde_json::to_string_pretty(&values.into_iter().collect::<HashMap<_, _>>())?
                );
            } else {
                for (k, v) in values {
                    println!("{:>13} : {}", k, v.to_string());
                }
            }
        }
        SubCommand::ListScreeners => {
            for screener in Screener::all_screeners() {
                println!("{:?}", screener);
            }
        }
        SubCommand::ListIntervals => {
            for interval in Interval::all_intervals() {
                println!("{}", interval);
            }
        }
    };
    Ok(())
}

pub fn as_field_suffix(&self) -> String

Get the string representation of the interval as a suffix for a field.

pub fn all_intervals() -> &'static [Interval]

Examples found in repository

examples/tradingview_get.rs (line 249)

async fn main() -> Result<()> {
    let opts = Opts::parse();
    match opts.subcmd {
        SubCommand::Search(args) => {
            // Parse arguments
            let screener = args.screener;
            let exchanges = args.exchanges;
            let types = args.types;
            let name_filter = args.name;
            // Prepare extra fields if specified
            let extra_fields: Vec<FieldWithInterval> = args
                .fields
                .into_iter()
                .map(|x| FieldWithInterval::parse_undefined(&x))
                .collect();

            // Initialize TradingView client and search symbols with given parameters
            let tv = TradingView::new(&screener, "");
            let values = tv
                .search_symbols(&exchanges, &types, name_filter, &extra_fields)
                .await
                .context("search symbols error")?;

            // Prepare fields to be printed
            let fields = [
                Field::Exchange,
                Field::Name,
                Field::Type,
                Field::Description,
            ]
            .into_iter()
            .map(|x| x.with_interval(&Interval::default()))
            .chain(extra_fields.into_iter())
            .collect::<Vec<_>>();

            // Assemble data rows for output
            let mut table: Vec<Vec<String>> = vec![];
            for vals in values {
                let mut row = vec![];
                for field in fields.iter() {
                    let val = vals
                        .values()
                        .get(&field)
                        .map_or("".into(), |x| x.to_string());
                    row.push(val);
                }
                table.push(row);
            }

            // Print csv header
            println!(
                "{}",
                fields
                    .iter()
                    .map(|x| x.to_string())
                    .collect::<Vec<_>>()
                    .join(",")
            );
            // Print csv data rows
            for vals in table {
                println!("{}", vals.join(","));
            }
        }
        SubCommand::Scan(args) => {
            // Parse arguments
            let screener = args.screener;
            let exchange = args.exchange;
            let interval = Interval::parse_undefined(&args.default_interval);
            let symbols = args.symbols;
            // Prepare fields with default intervals if not specified
            let fields = args
                .fields
                .iter()
                .map(|x| FieldWithInterval::parse_undefined_with_default_interval(x, &interval))
                .collect::<Vec<_>>();

            // Initialize TradingView client and retrieve data for specified symbols and fields
            let tv = TradingView::new(&screener, exchange);
            let symbols = tv
                .scan_symbols(&symbols, &fields)
                .await
                .context("scan symbols error")?;

            // Assemble data rows for output
            let mut table: Vec<Vec<String>> = vec![];
            for vals in symbols {
                let mut row = vec![format!("\"{}\"", vals.symbol())];
                for field in fields.iter() {
                    let val = vals
                        .values()
                        .get(&field)
                        .map_or("".into(), |x| x.to_string());
                    row.push(val);
                }
                table.push(row);
            }

            // Print csv header
            println!(
                "symbol,{}",
                fields
                    .iter()
                    .map(|x| x.to_string())
                    .collect::<Vec<_>>()
                    .join(",")
            );
            // Print csv data rows
            for vals in table {
                println!("{}", vals.join(","));
            }
        }
        SubCommand::Get(args) => {
            // Parse arguments
            let screener = args.screener;
            let exchange = args.exchange;
            let interval = Interval::parse_undefined(&args.interval);
            let symbol = args.symbol;
            // Prepare fields with default intervals if not specified
            let fields = args
                .fields
                .iter()
                .map(|x| FieldWithInterval::parse_undefined_with_default_interval(x, &interval))
                .collect::<Vec<_>>();

            // Initialize TradingView client and retrieve data for specified symbol and fields
            let tv = TradingView::new(&screener, exchange);
            let symbol = tv
                .get_symbol_fields_with_interval(&symbol, &fields)
                .await
                .context("Failed to retrieve symbol fields")?;

            // Collect key-value pairs for output, including screener, symbol, interval, and field data
            let mut values: Vec<(String, Value)> = Vec::new();
            values.extend(vec![
                ("screener".to_string(), json!(screener.to_string())),
                ("symbol".to_string(), json!(symbol.symbol().to_string())),
                ("interval".to_string(), json!(interval.to_string())),
            ]);
            for field in &fields {
                if let Some(val) = symbol.values().get(field) {
                    values.push((field.to_string(), val.clone()));
                }
            }

            // Output data, formatted as JSON if specified, else as plain key-value pairs
            if args.json {
                println!(
                    "{}",
                    serde_json::to_string_pretty(&values.into_iter().collect::<HashMap<_, _>>())?
                );
            } else {
                for (k, v) in values {
                    println!("{:>13} : {}", k, v.to_string());
                }
            }
        }
        SubCommand::ListScreeners => {
            for screener in Screener::all_screeners() {
                println!("{:?}", screener);
            }
        }
        SubCommand::ListIntervals => {
            for interval in Interval::all_intervals() {
                println!("{}", interval);
            }
        }
    };
    Ok(())
}

Trait Implementations

impl AsRef<str> for Interval

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Interval

fn clone(&self) -> Interval

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Interval

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Interval

fn default() -> Self

Returns the “default value” for a type.

impl Display for Interval

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Interval

impl Hash for Interval

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Interval

fn eq(&self, other: &Interval) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Interval