1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
//! Algorithmia client library //! //! # Examples //! //! ```no_run //! use algorithmia::Algorithmia; //! use algorithmia::algo::{Algorithm, Version}; //! //! // Initialize with an API key //! let client = Algorithmia::client("111112222233333444445555566"); //! let moving_avg = client.algo(("timeseries/SimpleMovingAverage", "0.1")); //! //! // Run the algorithm using a type safe decoding of the output to Vec<int> //! // since this algorithm outputs results as a JSON array of integers //! let input = (vec![0,1,2,3,15,4,5,6,7], 3); //! let result: Vec<f64> = moving_avg.pipe(&input).unwrap().decode().unwrap(); //! println!("Completed with result: {:?}", result); //! ``` #![doc(html_logo_url = "https://algorithmia.com/assets/images/apple-touch-icon.png")] #[macro_use] extern crate hyper; extern crate rustc_serialize; use algo::{Algorithm, AlgoRef}; use data::{DataDir, DataFile, DataPath, HasDataPath}; use client::HttpClient; use std::clone; pub mod algo; pub mod data; pub mod error; pub mod client; pub use hyper::{mime, Url}; pub use client::ApiAuth::{self, SimpleAuth, NoAuth}; static DEFAULT_API_BASE_URL: &'static str = "https://api.algorithmia.com"; /// The top-level struct for instantiating Algorithmia client endpoints pub struct Algorithmia { http_client: HttpClient, } impl<'a, 'c> Algorithmia { /// Instantiate a new client /// /// Client should be instatiated with your API key, except /// when running within an algorithm on the Algorithmia platform. /// /// # Examples /// ``` /// use algorithmia::*; /// // Initialize a client /// let client = Algorithmia::client("simUseYourApiKey"); /// /// // Initialize a client (for algorithms running on the Algorithmia platform) /// let client = Algorithmia::client(NoAuth); /// ``` pub fn client<A: Into<ApiAuth>>(api_key: A) -> Algorithmia { let api_address = std::env::var("ALGORITHMIA_API").unwrap_or(DEFAULT_API_BASE_URL.into()); Algorithmia { http_client: HttpClient::new(api_key.into(), api_address), } } /// Instantiate a new client against alternate API servers pub fn alt_client<A: Into<ApiAuth>>(base_url: Url, api_key: A) -> Algorithmia { Algorithmia { http_client: HttpClient::new(api_key.into(), base_url.into_string()), } } /// Instantiate an [`Algorithm`](algo/algorithm.struct.html) from this client /// /// By using In /// # Examples /// /// ``` /// use algorithmia::Algorithmia; /// use algorithmia::algo::Version; /// let client = Algorithmia::client("111112222233333444445555566"); /// let factor = client.algo("anowell/Dijkstra/0.1"); /// let factor = client.algo(("anowell/Dijkstra", Version::Latest)); /// ``` pub fn algo<A: Into<AlgoRef>>(&self, algorithm: A) -> Algorithm { Algorithm::new(self.http_client.clone(), algorithm.into()) } /// Instantiate a `DataDirectory` from this client /// /// # Examples /// /// ``` /// use algorithmia::Algorithmia; /// let client = Algorithmia::client("111112222233333444445555566"); /// let rustfoo = client.dir("data://.my/rustfoo"); /// ``` pub fn dir(&self, path: &'a str) -> DataDir { DataDir::new(self.http_client.clone(), path) } /// Instantiate a `DataDirectory` from this client /// /// # Examples /// /// ``` /// use algorithmia::Algorithmia; /// let client = Algorithmia::client("111112222233333444445555566"); /// let rustfoo = client.file("data://.my/rustfoo"); /// ``` pub fn file(&self, path: &'a str) -> DataFile { DataFile::new(self.http_client.clone(), path) } /// Instantiate a `DataPath` from this client /// /// Use this if you don't explicitly know if a Data URI is to a directory or file /// /// # Examples /// /// ``` /// use algorithmia::Algorithmia; /// let client = Algorithmia::client("111112222233333444445555566"); /// let rustfoo = client.data("data://.my/rustfoo/what_am_i"); /// ``` pub fn data(&self, path: &'a str) -> DataPath { DataPath::new(self.http_client.clone(), path) } } /// Allow cloning in order to reuse http client (and API key) for multiple connections impl clone::Clone for Algorithmia { fn clone(&self) -> Algorithmia { Algorithmia { http_client: self.http_client.clone(), } } } impl Default for Algorithmia { fn default() -> Algorithmia { let api_address = std::env::var("ALGORITHMIA_API").unwrap_or(DEFAULT_API_BASE_URL.into()); let api_key = std::env::var("ALGORITHMIA_API_KEY").map(|s| SimpleAuth(s)).unwrap_or(NoAuth); Algorithmia { http_client: HttpClient::new(api_key, api_address) } } }