Struct GuruFocusConnector 

pub struct GuruFocusConnector { /* private fields */ }

Container for connection parameters to gurufocus server.

Implementations

impl GuruFocusConnector

pub fn new(token: String) -> GuruFocusConnector

Constructor for a new instance of GuruFocusConnector. token is the user token you get from gurufocus if you subscribe for a premium or premium plus account.

Examples found in repository

examples/09_gurulist.rs (line 7)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);
    let gurus = gf_connect.get_gurus().await.unwrap();

    // Print list of gurus
    println!("List of all Gurus: {}", gurus);
}

examples/12_exchanges.rs (line 10)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);
    let exchanges = gf_connect.get_exchanges().await.unwrap();
    let exchange_map: ExchangeList = serde_json::from_value(exchanges).unwrap();
    println!("{:#?}", exchange_map);
}

examples/14_insider_updates.rs (line 9)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let updates = gf_connect.get_insider_updates().await.unwrap();

    let updates: InsiderUpdaters = serde_json::from_value(updates).unwrap();
    println!("List of lasted insider updates\n{:#?}", updates);
}

examples/17_personal_portfolio.rs (line 9)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);
    let portfolios = gf_connect.get_personal_portfolio().await.unwrap();

    let portfolios: PersonalPortfolios = serde_json::from_value(portfolios).unwrap();
    println!("Personal portfolios overview\n{:#?}", portfolios);
}

examples/05a_price_history.rs (line 9)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let stock = "NYSE:DIS";
    let prices = gf_connect.get_price_hist(stock).await.unwrap();

    let prices: PriceHistory = serde_json::from_value(prices).unwrap();
    println!("Price history for Walt Disney\n{:#?}", prices);
}

examples/05b_price_history_unadj.rs (line 9)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let stock = "NYSE:DIS";
    let prices = gf_connect.get_unadj_price_hist(stock).await.unwrap();

    let prices: PriceHistory = serde_json::from_value(prices).unwrap();
    println!("Unadjusted Price history for Walt Disney\n{:#?}", prices);
}

Additional examples can be found in:

• examples/08_insider_trades.rs
• examples/16_analyst_estimate.rs
• examples/02_financials.rs
• examples/07_guru_trades.rs
• examples/15_dividend_history.rs
• examples/06_stock_summary.rs
• examples/04_quotes.rs
• examples/03_keyratios.rs
• examples/19_politicianlist.rs
• examples/13_stocklist.rs
• examples/18_fundamentals_update.rs
• examples/11_guru_portfolios.rs
• examples/20_politician_transactions.rs
• examples/10_guru_picks.rs

pub async fn get_financials(&self, stock: &str) -> Result<Value, GuruFocusError>

Returns the full history of financial data for stock symbol given as argument

Examples found in repository

examples/02_financials.rs (line 6)

async fn show_financials(ticker: &str, gf_connect: &gfapi::GuruFocusConnector) {
    let financials = gf_connect.get_financials(ticker).await.unwrap();
    let financials: gfapi::FinancialData = serde_json::from_value(financials).unwrap();
    println!(
        "Financial figures of {}'s Enterprice value\n==================\n{:#?}\n\n",
        ticker, financials
    );
}

pub async fn get_key_ratios(&self, stock: &str) -> Result<Value, GuruFocusError>

Returns the current key statistic figures for stock symbol given as argument

Examples found in repository

examples/03_keyratios.rs (line 11)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    // Get key ratios of Berkshire Hathaway
    let stock = "NYSE:BRK.A";
    let key_ratios = gf_connect.get_key_ratios(stock).await.unwrap();

    let key_ratios: gfapi::KeyRatios = serde_json::from_value(key_ratios).unwrap();
    println!(
        "List of key ratios for Berkshire Hathaway\n{:#?}",
        key_ratios
    );
}

pub async fn get_quotes(&self, stocks: &[&str]) -> Result<Value, GuruFocusError>

Returns the current quote data of a comma separated list of symbols given as argument

Examples found in repository

examples/04_quotes.rs (line 11)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);
    let ticker = ["NAS:AAPL", "FRA:APC", "LTS:0JQ4"];
    let prices = gf_connect.get_quotes(&ticker).await.unwrap();

    let prices: QuoteList = serde_json::from_value(prices).unwrap();
    println!("Compare latest quotes of Apple stock prices and three different exchanges:");
    println!("{:#?}", prices);
}

pub async fn get_price_hist(&self, stock: &str) -> Result<Value, GuruFocusError>

Returns the history of (adjusted) quoted prices for symbol given as argument

Examples found in repository

examples/05a_price_history.rs (line 12)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let stock = "NYSE:DIS";
    let prices = gf_connect.get_price_hist(stock).await.unwrap();

    let prices: PriceHistory = serde_json::from_value(prices).unwrap();
    println!("Price history for Walt Disney\n{:#?}", prices);
}

pub async fn get_unadj_price_hist( &self, stock: &str, ) -> Result<Value, GuruFocusError>

Returns the history of (unadjusted) quoted prices for symbol given as argument

Examples found in repository

examples/05b_price_history_unadj.rs (line 12)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let stock = "NYSE:DIS";
    let prices = gf_connect.get_unadj_price_hist(stock).await.unwrap();

    let prices: PriceHistory = serde_json::from_value(prices).unwrap();
    println!("Unadjusted Price history for Walt Disney\n{:#?}", prices);
}

pub async fn get_stock_summary( &self, stock: &str, ) -> Result<Value, GuruFocusError>

Returns companies current price, valuation rations and ranks for symbol given as argument

Examples found in repository

examples/06_stock_summary.rs (line 10)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let stock = "NYSE:BAC";
    let stock_summary = gf_connect.get_stock_summary(stock).await.unwrap();

    let stock_summary: gfapi::StockSummary = serde_json::from_value(stock_summary).unwrap();
    println!(
        "Stock summary for Bank of America\n{:#?}",
        stock_summary.summary
    );
}

pub async fn get_guru_trades( &self, stock: &str, ) -> Result<Value, GuruFocusError>

Returns real-time guru trades and holding data for symbol given as argument

Examples found in repository

examples/07_guru_trades.rs (line 11)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let stock = "WMT";
    let trades = gf_connect.get_guru_trades(stock).await.unwrap();

    let trades: HashMap<String, gfapi::gurus::GuruTrades> = serde_json::from_value(trades).unwrap();
    println!("List of real time guru trades in Walmart\n{:#?}", trades);
}

pub async fn get_insider_trades( &self, stock: &str, ) -> Result<Value, GuruFocusError>

Returns real-time insider trades for symbol given as argument

Examples found in repository

examples/08_insider_trades.rs (line 13)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let stock = "NAS:NVDA";
    let trades = gf_connect.get_insider_trades(stock).await.unwrap();

    let trades: InsiderTrades = serde_json::from_value(trades).unwrap();
    println!("List of real time insider trades in NVDIA\n{:#?}", trades);
}

pub async fn get_gurus(&self) -> Result<Value, GuruFocusError>

Returns lists of all and personalized gurus

Examples found in repository

examples/09_gurulist.rs (line 8)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);
    let gurus = gf_connect.get_gurus().await.unwrap();

    // Print list of gurus
    println!("List of all Gurus: {}", gurus);
}

pub async fn get_guru_picks( &self, gurus: &[&str], start_date: Date, page: i32, ) -> Result<Value, GuruFocusError>

Returns list of gurus stock picks using list of guru ids since a given start date.

Examples found in repository

examples/10_guru_picks.rs (line 33)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    // Buffett, Soros and Klarman
    let gurus = ["7", "16", "28"];
    let now = UtcDateTime::now();
    let three_months_ago = get_months_before(now.date(), 3);
    let page = 1;
    let trades = gf_connect
        .get_guru_picks(&gurus, three_months_ago, page)
        .await
        .unwrap();

    println!(
        "List of trades by a set of gurus (Warren Buffett, George Soros, and Seth Klarman) since {}\n{:#?}", three_months_ago, trades);
}

pub async fn get_guru_portfolios( &self, gurus: &[&str], ) -> Result<Value, GuruFocusError>

Returns list of aggregated guru portfolios given a slice of guru ids

Examples found in repository

examples/11_guru_portfolios.rs (line 12)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    // Bill Ackman and David Einhorn
    let gurus = ["47", "39"];
    let portfolios = gf_connect.get_guru_portfolios(&gurus).await.unwrap();

    let portfolios: HashMap<String, gfapi::gurus::GuruPortfolio> =
        serde_json::from_value(portfolios).unwrap();
    println!(
        "Aggregated Portfolios of Bill Ackman and David Einhorn\n{:#?}",
        portfolios
    );
}

pub async fn get_exchanges(&self) -> Result<Value, GuruFocusError>

Returns list of supported exchanges

Examples found in repository

examples/12_exchanges.rs (line 11)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);
    let exchanges = gf_connect.get_exchanges().await.unwrap();
    let exchange_map: ExchangeList = serde_json::from_value(exchanges).unwrap();
    println!("{:#?}", exchange_map);
}

pub async fn get_listed_stocks( &self, exchange: &str, ) -> Result<Value, GuruFocusError>

Returns list of all stocks of a particular exchange

Examples found in repository

examples/13_stocklist.rs (line 12)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);
    // Get all stocks listed at the Oslo stock exchange (OSL) in Norway
    let exchange = "OSL";
    let stocks = gf_connect.get_listed_stocks(exchange).await.unwrap();
    let stocks: StockList = serde_json::from_value(stocks).unwrap();
    println!(
        "List of all stocks listed at the Oslo stock exchange (OSL) in Norway\n{:#?}",
        stocks
    );
}

pub async fn get_insider_updates(&self) -> Result<Value, GuruFocusError>

Returns list of latest insider trades ordered by insider transctions time

Examples found in repository

examples/14_insider_updates.rs (line 11)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let updates = gf_connect.get_insider_updates().await.unwrap();

    let updates: InsiderUpdaters = serde_json::from_value(updates).unwrap();
    println!("List of lasted insider updates\n{:#?}", updates);
}

pub async fn get_dividend_history( &self, stock: &str, ) -> Result<Value, GuruFocusError>

Returns 30 years dividend history data of a stock

Examples found in repository

examples/15_dividend_history.rs (line 12)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let stock = "NAS:MSFT";
    let dividends = gf_connect.get_dividend_history(stock).await.unwrap();

    let dividends: DividendHistory = serde_json::from_value(dividends).unwrap();
    println!("Microsoft's dividend history\n");
    for div in dividends {
        println!("{:?}", div);
    }
}

pub async fn get_analyst_estimate( &self, stock: &str, ) -> Result<Value, GuruFocusError>

Returns analyst estimate data of a stock

Examples found in repository

examples/16_analyst_estimate.rs (line 10)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let stock = "NAS:CSCO";
    let estimates = gf_connect.get_analyst_estimate(stock).await.unwrap();

    let estimates: gfapi::AnalystEstimates = serde_json::from_value(estimates).unwrap();
    println!("Analyst estimates on Cisco\n{:#?}", estimates);
}

pub async fn get_personal_portfolio(&self) -> Result<Value, GuruFocusError>

Returns list of personal portfolios

Examples found in repository

examples/17_personal_portfolio.rs (line 10)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);
    let portfolios = gf_connect.get_personal_portfolio().await.unwrap();

    let portfolios: PersonalPortfolios = serde_json::from_value(portfolios).unwrap();
    println!("Personal portfolios overview\n{:#?}", portfolios);
}

pub async fn get_updated_stocks( &self, date: Date, ) -> Result<Value, GuruFocusError>

Returns list of all stocks with updated fundamental data within a week of the given date

Examples found in repository

examples/18_fundamentals_update.rs (line 31)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);

    let now = UtcDateTime::now().date();
    let one_months_ago = get_months_before(now, 6);
    let stocks = gf_connect.get_updated_stocks(one_months_ago).await.unwrap();

    let stocks: UpdatedStocks = serde_json::from_value(stocks).unwrap();
    println!(
        "List of stocks with updated fundamental data since {}\n{:#?}",
        one_months_ago, stocks
    );
}

pub async fn get_politicians(&self) -> Result<Value, GuruFocusError>

Returns lists of politicians

Examples found in repository

examples/19_politicianlist.rs (line 8)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);
    let politicians = gf_connect.get_politicians().await.unwrap();
    let politicians: Vec<gfapi::gurus::Politician> = serde_json::from_value(politicians).unwrap();

    // Print list of politicians
    println!("List of politicians:");
    for p in politicians {
        println!("{}, {}, {}", p.full_name, p.party, p.position);
    }
}

pub async fn get_politician_transactions( &self, page: u32, asset_type: Option<AssetType>, ) -> Result<Value, GuruFocusError>

Examples found in repository

examples/20_politician_transactions.rs (line 12)

async fn main() {
    let token = env::var("GURUFOCUS_TOKEN").unwrap();
    let gf_connect = gfapi::GuruFocusConnector::new(token);
    let page = 1;
    let asset_type = None;

    let transactions = gf_connect
        .get_politician_transactions(page, asset_type)
        .await
        .unwrap();
    let transactions: gfapi::gurus::PoliticianTransactionList =
        serde_json::from_value(transactions).unwrap();

    println!("List of politician transactions");
    for t in transactions.data {
        println!("{t:?}");
    }
}