file_name large_stringlengths 4 140 | prefix large_stringlengths 0 12.1k | suffix large_stringlengths 0 12k | middle large_stringlengths 0 7.51k | fim_type large_stringclasses 4
values |
|---|---|---|---|---|
tools.js | lowest;
},
// returns float with 2 decimals
calculateAvgPlusHighThreshold: function(avg_for_period, high_threshold) {
return parseFloat((avg_for_period * (1 + high_threshold)).toFixed(2));
},
// returns float
calculateAvgMinusLowThreshold: function(avg_for_period, low_threshold) {
return parseFloat((avg_for_period * (1 - low_threshold)).toFixed(2));
},
/*
* this function takes a slide of the array (144 values for a day, fewer for other periods) and decides on selling or buying
*/
decideBuyOrSell: function(data_to_be_tested, latest_buy_price, latest_sell_price, low_threshold, high_threshold, buy_sell_method, print_full_debug, use_loop_fn) {
if (buy_sell_method === 'avg') {
//var start_c = new Date();
if (use_loop_fn) {
var avg_for_period = this.calculateAverageLoop(data_to_be_tested) // get avg for period
} else {
var avg_for_period = this.calculateAverage(data_to_be_tested) // get avg for period
}
// debug
//console.log(avg_for_period + ' should equal ' + this.calculateAverage(data_to_be_tested))
//this.timing_section_c += ((new Date() - start_c))
//var start_d = new Date();
var avg_plus_high_threshold = this.calculateAvgPlusHighThreshold(avg_for_period, high_threshold);
var avg_minus_low_threshold = this.calculateAvgMinusLowThreshold(avg_for_period, low_threshold)
//this.timing_section_d += ((new Date() - start_d))
var sell = (latest_sell_price > avg_plus_high_threshold) ? true : false;
var buy = (latest_buy_price < avg_minus_low_threshold) ? true : false;
// console.log('- avg_for_period ' + avg_for_period)
// console.log('- avg_plus_high_threshold ' + avg_plus_high_threshold)
// console.log('- avg_minus_low_threshold ' + avg_minus_low_threshold)
// console.log('- high_threshold ' + high_threshold)
// console.log('- low_threshold ' + low_threshold)
// console.log('- sell ' + sell)
// console.log('- buy ' + buy)
if (print_full_debug) {
reporting.debug('avg_for_period: $' + avg_for_period.toFixed(2) + '<br>');// print avg result to browser
reporting.debug('(avg price plus high threshold ('+high_threshold+'%) is $' + avg_plus_high_threshold.toFixed(2) + ')<br />');
reporting.debug('(avg price minus low threshold ('+low_threshold+'%) is $' + avg_minus_low_threshold.toFixed(2) + ')<br />');
}
} else if (buy_sell_method === 'peak') {
var high_for_period = this.calculateHigh(data_to_be_tested) // get avg for period
var low_for_period = this.calculateLow(data_to_be_tested) // get avg for period
var high_minus_high_threshold = (high_for_period * (1 - high_threshold)).toFixed(2);
var low_plus_low_threshold = (low_for_period * (1 + low_threshold)).toFixed(2);
var sell = (latest_sell_price > high_minus_high_threshold) ? true : false;
var buy = (latest_buy_price < low_plus_low_threshold) ? true : false;
if (print_full_debug) {
reporting.debug('high_for_period is: $' + high_for_period + '<br>');// print avg result to browser
reporting.debug('low_for_period is: $' + low_for_period + '<br>');// print avg result to browser
reporting.debug('high_minus_high_threshold is: $' + high_minus_high_threshold + '<br>');// print avg result to browser
reporting.debug('low_plus_low_threshold is: $' + low_plus_low_threshold + '<br>');// print avg result to browser
}
} else {
return;
}
if (sell) {
return 'sell';
} else if (buy) {
return 'buy';
} else {
return 'do_nothing';
}
},
calculateValuesForGivenPeriod: function(hrs_in_period, interval_in_minutes) {
return ((hrs_in_period * 60) / interval_in_minutes); // 144 10-min incremetns in a 24 hr period)
},
sellCoin: function(high_threshold, print_full_debug, sell_all, total_coins_owned, buy_sell_unit, current_coin_price_sell) {
// wrapper must check for 0 coins
if (sell_all) {
var number_of_coins_to_sell = total_coins_owned // SELL EVERYTHING
} else {
var number_of_coins_to_sell = (buy_sell_unit / current_coin_price_sell) // SELL LIMIT
if (number_of_coins_to_sell > total_coins_owned) {
number_of_coins_to_sell = total_coins_owned
}
}
var result_of_this_sale = (current_coin_price_sell * number_of_coins_to_sell)
var transaction_notes = 'Selling ' + number_of_coins_to_sell + ' coins values at $' + current_coin_price_sell.toFixed(2) + ' each for a total sale of $' + result_of_this_sale.toFixed(2);
if (print_full_debug) {
reporting.debug('<span style="color:red">TRANSACTION: SELL ' + number_of_coins_to_sell + ' of my ' + total_coins_owned + ' coins valued at $');
reporting.debug(current_coin_price_sell + ' = $' + result_of_this_sale + '</span><br />');
}
return {
number_of_coins_to_sell : number_of_coins_to_sell,
result_of_this_sale : result_of_this_sale,
transaction_notes : transaction_notes
}
},
buyCoin: function(total_coins_owned, buy_sell_unit, current_coin_price_buy, print_full_debug, latest_sell_price, total_spent, total_sold, money_in_bank, reinvest_profit) {
// expected number of coins to buy
var number_of_coins_to_buy = (buy_sell_unit / current_coin_price_buy);
var amount_spent_on_this_transaction = buy_sell_unit;
var transaction_notes = 'Buying ' + number_of_coins_to_buy + ' coins valued at $' + current_coin_price_buy.toFixed(2) + ' each for a total purchase of $' + amount_spent_on_this_transaction.toFixed(2);
if (print_full_debug) {
reporting.debug('buy_sell_unit: ' + buy_sell_unit + '<br />');
reporting.debug('current_coin_price_buy: ' + current_coin_price_buy + '<br />');
reporting.debug('total_coins_owned: ' + total_coins_owned + '<br />');
reporting.debug('number_of_coins_to_buy: ' + number_of_coins_to_buy + '<br />');
reporting.debug('amount_spent_on_this_transaction: ' + amount_spent_on_this_transaction + '<br />');
}
var current_position = this.calculateCurrentPosition(total_coins_owned, latest_sell_price, total_sold, total_spent)
// if currnet_positon is negative it screws this up, so i added in this little extra rule. if crurr pos is less than 0, then just check if we have money.
if (reinvest_profit || (current_position <= 0)) {
var reached_limit = (money_in_bank < buy_sell_unit) // THIS WILL SPEND PROFIT
} else {
var reached_limit = ((money_in_bank - buy_sell_unit) < current_position) // THIS WILL RETAIN PROFIT
// console.log('***checking limit:')
// console.log('total_coins_owned: ' + total_coins_owned);
// console.log('latest_sell_price: ' + latest_sell_price);
// console.log('total_sold: ' + total_sold);
// console.log('total_spent: ' + total_spent);
// console.log('current_position: ' + current_position);
// console.log('money_in_bank: ' + money_in_bank);
// console.log('buy_sell_unit: ' + buy_sell_unit);
// console.log('reached_limit: ' + reached_limit);
}
if (reached_limit) {
number_of_coins_to_buy = 0;
amount_spent_on_this_transaction = 0;
transaction_notes = '***reached limit*** setting number_of_coins_to_buy/amount_spent_on_this_transaction to 0';
transaction_notes += ' (money_in_bank: ' + money_in_bank + ', buy_sell_unit: ' + buy_sell_unit + ', current_position: ' + current_position + ')';
if (print_full_debug) {
reporting.debug('***reached limit!***<br />')
reporting.debug('---setting number_of_coins_to_buy and amount_spent_on_this_transaction to 0<br />');
} | }
else { | random_line_split | |
tools.js | this.sum - this.sum_last + data_to_be_tested[len - 1].value_avg
}
this.sum_last = data_to_be_tested[0].value_avg;
return parseFloat((this.sum/len).toFixed(2));
},
// return highest sell price
// *****IT IS USING BUY PRICE! which should it be?
calculateHigh: function(data_to_be_tested) {
var highest = 0
for (j=0; j < data_to_be_tested.length; j++) {
highest = (data_to_be_tested[j].value_buy > highest) ? data_to_be_tested[j].value_buy : highest;
}
return highest;
},
calculateLow: function(data_to_be_tested) {
// return lowest buy price
var lowest = data_to_be_tested[0].value_sell;
for (j=0; j < data_to_be_tested.length; j++) {
lowest = (data_to_be_tested[j].value_sell < lowest) ? data_to_be_tested[j].value_sell : lowest;
}
return lowest;
},
// returns float with 2 decimals
calculateAvgPlusHighThreshold: function(avg_for_period, high_threshold) {
return parseFloat((avg_for_period * (1 + high_threshold)).toFixed(2));
},
// returns float
calculateAvgMinusLowThreshold: function(avg_for_period, low_threshold) {
return parseFloat((avg_for_period * (1 - low_threshold)).toFixed(2));
},
/*
* this function takes a slide of the array (144 values for a day, fewer for other periods) and decides on selling or buying
*/
decideBuyOrSell: function(data_to_be_tested, latest_buy_price, latest_sell_price, low_threshold, high_threshold, buy_sell_method, print_full_debug, use_loop_fn) {
if (buy_sell_method === 'avg') {
//var start_c = new Date();
if (use_loop_fn) {
var avg_for_period = this.calculateAverageLoop(data_to_be_tested) // get avg for period
} else {
var avg_for_period = this.calculateAverage(data_to_be_tested) // get avg for period
}
// debug
//console.log(avg_for_period + ' should equal ' + this.calculateAverage(data_to_be_tested))
//this.timing_section_c += ((new Date() - start_c))
//var start_d = new Date();
var avg_plus_high_threshold = this.calculateAvgPlusHighThreshold(avg_for_period, high_threshold);
var avg_minus_low_threshold = this.calculateAvgMinusLowThreshold(avg_for_period, low_threshold)
//this.timing_section_d += ((new Date() - start_d))
var sell = (latest_sell_price > avg_plus_high_threshold) ? true : false;
var buy = (latest_buy_price < avg_minus_low_threshold) ? true : false;
// console.log('- avg_for_period ' + avg_for_period)
// console.log('- avg_plus_high_threshold ' + avg_plus_high_threshold)
// console.log('- avg_minus_low_threshold ' + avg_minus_low_threshold)
// console.log('- high_threshold ' + high_threshold)
// console.log('- low_threshold ' + low_threshold)
// console.log('- sell ' + sell)
// console.log('- buy ' + buy)
if (print_full_debug) {
reporting.debug('avg_for_period: $' + avg_for_period.toFixed(2) + '<br>');// print avg result to browser
reporting.debug('(avg price plus high threshold ('+high_threshold+'%) is $' + avg_plus_high_threshold.toFixed(2) + ')<br />');
reporting.debug('(avg price minus low threshold ('+low_threshold+'%) is $' + avg_minus_low_threshold.toFixed(2) + ')<br />');
}
} else if (buy_sell_method === 'peak') | else {
return;
}
if (sell) {
return 'sell';
} else if (buy) {
return 'buy';
} else {
return 'do_nothing';
}
},
calculateValuesForGivenPeriod: function(hrs_in_period, interval_in_minutes) {
return ((hrs_in_period * 60) / interval_in_minutes); // 144 10-min incremetns in a 24 hr period)
},
sellCoin: function(high_threshold, print_full_debug, sell_all, total_coins_owned, buy_sell_unit, current_coin_price_sell) {
// wrapper must check for 0 coins
if (sell_all) {
var number_of_coins_to_sell = total_coins_owned // SELL EVERYTHING
} else {
var number_of_coins_to_sell = (buy_sell_unit / current_coin_price_sell) // SELL LIMIT
if (number_of_coins_to_sell > total_coins_owned) {
number_of_coins_to_sell = total_coins_owned
}
}
var result_of_this_sale = (current_coin_price_sell * number_of_coins_to_sell)
var transaction_notes = 'Selling ' + number_of_coins_to_sell + ' coins values at $' + current_coin_price_sell.toFixed(2) + ' each for a total sale of $' + result_of_this_sale.toFixed(2);
if (print_full_debug) {
reporting.debug('<span style="color:red">TRANSACTION: SELL ' + number_of_coins_to_sell + ' of my ' + total_coins_owned + ' coins valued at $');
reporting.debug(current_coin_price_sell + ' = $' + result_of_this_sale + '</span><br />');
}
return {
number_of_coins_to_sell : number_of_coins_to_sell,
result_of_this_sale : result_of_this_sale,
transaction_notes : transaction_notes
}
},
buyCoin: function(total_coins_owned, buy_sell_unit, current_coin_price_buy, print_full_debug, latest_sell_price, total_spent, total_sold, money_in_bank, reinvest_profit) {
// expected number of coins to buy
var number_of_coins_to_buy = (buy_sell_unit / current_coin_price_buy);
var amount_spent_on_this_transaction = buy_sell_unit;
var transaction_notes = 'Buying ' + number_of_coins_to_buy + ' coins valued at $' + current_coin_price_buy.toFixed(2) + ' each for a total purchase of $' + amount_spent_on_this_transaction.toFixed(2);
if (print_full_debug) {
reporting.debug('buy_sell_unit: ' + buy_sell_unit + '<br />');
reporting.debug('current_coin_price_buy: ' + current_coin_price_buy + '<br />');
reporting.debug('total_coins_owned: ' + total_coins_owned + '<br />');
reporting.debug('number_of_coins_to_buy: ' + number_of_coins_to_buy + '<br />');
reporting.debug('amount_spent_on_this_transaction: ' + amount_spent_on_this_transaction + '<br />');
}
var current_position = this.calculateCurrentPosition(total_coins_owned, latest_sell_price, total_sold, total_spent)
// if currnet_positon is negative it screws this up, so i added in this little extra rule. if crurr pos is less than 0, then just check if we have money.
if (reinvest_profit || (current_position <= 0)) {
var reached_limit = (money_in_bank < buy_sell_unit) // THIS WILL SPEND PROFIT
} else {
var reached_limit = ((money_in_bank - buy_sell_unit) < current_position) // THIS WILL RETAIN PROFIT
// console.log('***checking limit:')
// console.log('total_coins_owned: ' + total_coins_owned);
// console.log('latest_sell_price: ' + latest_sell_price);
// console.log('total_sold: ' | {
var high_for_period = this.calculateHigh(data_to_be_tested) // get avg for period
var low_for_period = this.calculateLow(data_to_be_tested) // get avg for period
var high_minus_high_threshold = (high_for_period * (1 - high_threshold)).toFixed(2);
var low_plus_low_threshold = (low_for_period * (1 + low_threshold)).toFixed(2);
var sell = (latest_sell_price > high_minus_high_threshold) ? true : false;
var buy = (latest_buy_price < low_plus_low_threshold) ? true : false;
if (print_full_debug) {
reporting.debug('high_for_period is: $' + high_for_period + '<br>');// print avg result to browser
reporting.debug('low_for_period is: $' + low_for_period + '<br>');// print avg result to browser
reporting.debug('high_minus_high_threshold is: $' + high_minus_high_threshold + '<br>');// print avg result to browser
reporting.debug('low_plus_low_threshold is: $' + low_plus_low_threshold + '<br>');// print avg result to browser
}
} | conditional_block |
lib.rs | pub struct Keys<'a, K, V> {
inner: Iter<'a, K, V>,
}
impl<'a, K, V> Iterator for Keys<'a, K, V> {
type Item = &'a K;
#[inline]
fn next(&mut self) -> Option<&'a K> {
self.inner.next().map(|(k, _)| k)
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
}
//#[derive(Clone)]
/// Iterator over the values
pub struct Values<'a, K, V> {
inner: Iter<'a, K, V>,
}
impl<'a, K, V> Iterator for Values<'a, K, V> {
type Item = &'a V;
#[inline]
fn next(&mut self) -> Option<&'a V> {
self.inner.next().map(|(_, v)| v)
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
}
#[derive(Clone)]
struct Node<K, V> {
// Key
pub key: K,
// Hash of the key
pub hash: u64,
// Value stored. We'll use `None` as a sentinel value for removed
// entries.
pub value: Option<V>,
// Store vector index pointing to the `Node` for which `hash` is smaller
// than that of this `Node`.
pub left: Cell<Option<NonZeroU32>>,
// Same as above but for `Node`s with hash larger than this one. If the
// hash is the same, but keys are different, the lookup will default
// to the right branch as well.
pub right: Cell<Option<NonZeroU32>>,
}
impl<K, V> fmt::Debug for Node<K, V>
where
K: fmt::Debug,
V: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Debug::fmt(
&(&self.key, &self.value, self.left.get(), self.right.get()),
f,
)
}
}
impl<K, V> PartialEq for Node<K, V>
where
K: PartialEq,
V: PartialEq,
{
fn eq(&self, other: &Self) -> bool {
self.hash == other.hash && self.key == other.key && self.value == other.value
}
}
impl<K, V> Node<K, V> {
#[inline]
const fn new(key: K, value: V, hash: u64) -> Self {
Node {
key,
hash,
value: Some(value),
left: Cell::new(None),
right: Cell::new(None),
}
}
}
// `Cell` isn't `Sync`, but all of our writes are contained and require
// `&mut` access, ergo this is safe.
unsafe impl<K: Sync, V: Sync> Sync for Node<K, V> {}
/// A binary tree implementation of a string -> `JsonValue` map. You normally don't
/// have to interact with instances of `Object`, much more likely you will be
/// using the `JsonValue::Object` variant, which wraps around this struct.
#[derive(Debug, Clone)]
pub struct Map<K, V, H = AHasher> {
store: Vec<Node<K, V>>,
hasher: PhantomData<H>,
}
enum FindResult<'find> {
Hit(usize),
Miss(Option<&'find Cell<Option<NonZeroU32>>>),
}
use FindResult::*;
impl<K, V> Map<K, V, AHasher> {
/// Create a new `Map`.
#[inline]
pub fn new() -> Self {
Map::<K, V, AHasher>::default()
}
/// Create a `Map` with a given capacity
#[inline]
pub fn with_capacity(capacity: usize) -> Self {
Map {
store: Vec::with_capacity(capacity),
hasher: PhantomData,
}
}
}
impl<K, V, H> Default for Map<K, V, H> {
/// Create a new `Map` with a custom hasher.
#[inline]
fn default() -> Self {
Map {
store: Vec::new(),
hasher: PhantomData,
}
}
}
impl<K, V, H> Map<K, V, H>
where
K: Hash + Eq,
H: Hasher + Default,
{
/// An iterator visiting all keys in arbitrary order.
/// The iterator element type is `&'a K`.
pub fn keys(&self) -> Keys<'_, K, V> {
Keys { inner: self.iter() }
}
/// An iterator visiting all values in arbitrary order.
/// The iterator element type is `&'a V`.
pub fn values(&self) -> Values<'_, K, V> {
Values { inner: self.iter() }
}
/// Inserts a key-value pair into the map.
///
/// If the map did not have this key present, `None` is returned.
///
/// If the map did have this key present, the value is updated, and the old
/// value is returned. The key is not updated, though; this matters for
/// types that can be `==` without being identical.
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// assert_eq!(map.insert(37, "a"), None);
/// assert_eq!(map.is_empty(), false);
///
/// map.insert(37, "b");
/// assert_eq!(map.insert(37, "c"), Some("b"));
/// assert_eq!(map[&37], "c");
/// ```
pub fn insert(&mut self, key: K, value: V) -> Option<V> {
let hash = Self::hash_key(&key);
match self.find(hash) {
Hit(idx) => unsafe { self.store.get_unchecked_mut(idx).value.replace(value) },
Miss(parent) => {
if let Some(parent) = parent {
parent.set(NonZeroU32::new(self.store.len() as u32));
}
self.store.push(Node::new(key, value, hash));
None
}
}
}
/// Returns a reference to the value corresponding to the key.
///
/// The key may be any borrowed form of the map's key type, but `Hash` and
/// `Eq` on the borrowed form must match those for the key type.
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// map.insert(1, "a");
/// assert_eq!(map.get(&1), Some(&"a"));
/// assert_eq!(map.get(&2), None);
/// ```
pub fn get<Q>(&self, key: &Q) -> Option<&V>
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
let hash = Self::hash_key(key);
match self.find(hash) {
Hit(idx) => {
let node = unsafe { self.store.get_unchecked(idx) };
node.value.as_ref()
}
Miss(_) => None,
}
}
/// Returns a mutable reference to the value corresponding to the key.
///
/// The key may be any borrowed form of the map's key type, but Hash and Eq
/// on the borrowed form must match those for the key type.
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// map.insert(1, "a");
/// if let Some(x) = map.get_mut(&1) {
/// *x = "b";
/// }
/// assert_eq!(map[&1], "b");
/// ```
pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
let hash = Self::hash_key(key);
match self.find(hash) {
Hit(idx) => unsafe { self.store.get_unchecked_mut(idx).value.as_mut() },
Miss(_) => None,
}
}
/// Returns `true` if the map contains a value for the specified key.
///
/// The key may be any borrowed form of the map's key type, but `Hash` and
/// `Eq` on the borrowed form must match those for the key type.
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// map.insert(1, "a");
/// assert_eq!(map.contains_key(&1), true);
/// assert_eq!(map.contains_key(&2), false);
/// ```
pub fn contains_key<Q>(&self, key: &Q) -> bool
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
let hash = Self::hash_key(key);
match | // use alloc::vec::Vec;
/// Iterator over the keys | random_line_split | |
lib.rs | Map`.
#[inline]
pub fn new() -> Self {
Map::<K, V, AHasher>::default()
}
/// Create a `Map` with a given capacity
#[inline]
pub fn with_capacity(capacity: usize) -> Self {
Map {
store: Vec::with_capacity(capacity),
hasher: PhantomData,
}
}
}
impl<K, V, H> Default for Map<K, V, H> {
/// Create a new `Map` with a custom hasher.
#[inline]
fn default() -> Self {
Map {
store: Vec::new(),
hasher: PhantomData,
}
}
}
impl<K, V, H> Map<K, V, H>
where
K: Hash + Eq,
H: Hasher + Default,
{
/// An iterator visiting all keys in arbitrary order.
/// The iterator element type is `&'a K`.
pub fn | (&self) -> Keys<'_, K, V> {
Keys { inner: self.iter() }
}
/// An iterator visiting all values in arbitrary order.
/// The iterator element type is `&'a V`.
pub fn values(&self) -> Values<'_, K, V> {
Values { inner: self.iter() }
}
/// Inserts a key-value pair into the map.
///
/// If the map did not have this key present, `None` is returned.
///
/// If the map did have this key present, the value is updated, and the old
/// value is returned. The key is not updated, though; this matters for
/// types that can be `==` without being identical.
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// assert_eq!(map.insert(37, "a"), None);
/// assert_eq!(map.is_empty(), false);
///
/// map.insert(37, "b");
/// assert_eq!(map.insert(37, "c"), Some("b"));
/// assert_eq!(map[&37], "c");
/// ```
pub fn insert(&mut self, key: K, value: V) -> Option<V> {
let hash = Self::hash_key(&key);
match self.find(hash) {
Hit(idx) => unsafe { self.store.get_unchecked_mut(idx).value.replace(value) },
Miss(parent) => {
if let Some(parent) = parent {
parent.set(NonZeroU32::new(self.store.len() as u32));
}
self.store.push(Node::new(key, value, hash));
None
}
}
}
/// Returns a reference to the value corresponding to the key.
///
/// The key may be any borrowed form of the map's key type, but `Hash` and
/// `Eq` on the borrowed form must match those for the key type.
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// map.insert(1, "a");
/// assert_eq!(map.get(&1), Some(&"a"));
/// assert_eq!(map.get(&2), None);
/// ```
pub fn get<Q>(&self, key: &Q) -> Option<&V>
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
let hash = Self::hash_key(key);
match self.find(hash) {
Hit(idx) => {
let node = unsafe { self.store.get_unchecked(idx) };
node.value.as_ref()
}
Miss(_) => None,
}
}
/// Returns a mutable reference to the value corresponding to the key.
///
/// The key may be any borrowed form of the map's key type, but Hash and Eq
/// on the borrowed form must match those for the key type.
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// map.insert(1, "a");
/// if let Some(x) = map.get_mut(&1) {
/// *x = "b";
/// }
/// assert_eq!(map[&1], "b");
/// ```
pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
let hash = Self::hash_key(key);
match self.find(hash) {
Hit(idx) => unsafe { self.store.get_unchecked_mut(idx).value.as_mut() },
Miss(_) => None,
}
}
/// Returns `true` if the map contains a value for the specified key.
///
/// The key may be any borrowed form of the map's key type, but `Hash` and
/// `Eq` on the borrowed form must match those for the key type.
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// map.insert(1, "a");
/// assert_eq!(map.contains_key(&1), true);
/// assert_eq!(map.contains_key(&2), false);
/// ```
pub fn contains_key<Q>(&self, key: &Q) -> bool
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
let hash = Self::hash_key(key);
match self.find(hash) {
Hit(idx) => unsafe { self.store.get_unchecked(idx).value.is_some() },
Miss(_) => false,
}
}
/// Get a mutable reference to entry at key. Inserts a new entry by
/// calling `F` if absent.
// TODO: Replace with entry API
pub fn get_or_insert<F>(&mut self, key: K, fill: F) -> &mut V
where
F: FnOnce() -> V,
{
let hash = Self::hash_key(&key);
match self.find(hash) {
Hit(idx) => {
let node = unsafe { self.store.get_unchecked_mut(idx) };
if node.value.is_none() {
node.value = Some(fill());
}
node.value.as_mut().unwrap()
}
Miss(parent) => {
let idx = self.store.len();
if let Some(parent) = parent {
parent.set(NonZeroU32::new(self.store.len() as u32));
}
self.store.push(Node::new(key, fill(), hash));
self.store[idx].value.as_mut().unwrap()
}
}
}
/// Removes a key from the map, returning the value at the key if the key
/// was previously in the map.
///
/// The key may be any borrowed form of the map's key type, but `Hash` and
/// `Eq` on the borrowed form must match those for the key type.
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// map.insert(1, "a");
/// assert_eq!(map.remove(&1), Some("a"));
/// assert_eq!(map.remove(&1), None);
/// ```
pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
let hash = Self::hash_key(key);
match self.find(hash) {
Hit(idx) => unsafe { self.store.get_unchecked_mut(idx).value.take() },
Miss(_) => return None,
}
}
/// Returns the number of elements in the map.
#[inline]
pub fn len(&self) -> usize {
self.store.len()
}
/// Returns `true` if the map contains no elements.
#[inline]
pub fn is_empty(&self) -> bool {
self.store.is_empty()
}
/// Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.
#[inline]
pub fn clear(&mut self) {
self.store.clear();
}
#[inline]
fn find(&self, hash: u64) -> FindResult {
if self.len() == 0 {
return Miss(None);
}
let mut idx = 0;
loop {
let node = unsafe { self.store.get_unchecked(idx) };
if hash < node.hash {
match node.left.get() {
Some(i) => idx = i.get() as usize,
None => return Miss(Some(&node.left)),
}
} else if hash > node.hash {
match node.right.get() {
Some(i) => idx = i.get() as usize,
None => return Miss(Some(&node.right)),
}
} else {
return Hit(idx);
}
}
}
#[inline]
fn hash_key<Q: Hash>(key: Q) -> u64 {
// let mut hasher = fnv::FnvHasher::default();
// let mut hasher = rustc_hash::FxHasher::default();
let mut hasher = H::default();
key.hash(&mut hasher);
hasher.finish()
}
/// An iterator visiting all key-value pairs in insertion | keys | identifier_name |
lib.rs | : self.store.iter_mut(),
}
}
/// Creates a raw entry builder for the HashMap.
///
/// Raw entries provide the lowest level of control for searching and
/// manipulating a map. They must be manually initialized with a hash and
/// then manually searched. After this, insertions into a vacant entry
/// still require an owned key to be provided.
///
/// Raw entries are useful for such exotic situations as:
///
/// * Hash memoization
/// * Deferring the creation of an owned key until it is known to be required
/// * Using a search key that doesn't work with the Borrow trait
/// * Using custom comparison logic without newtype wrappers
///
/// Because raw entries provide much more low-level control, it's much easier
/// to put the HashMap into an inconsistent state which, while memory-safe,
/// will cause the map to produce seemingly random results. Higher-level and
/// more foolproof APIs like `entry` should be preferred when possible.
///
/// In particular, the hash used to initialized the raw entry must still be
/// consistent with the hash of the key that is ultimately stored in the entry.
/// This is because implementations of HashMap may need to recompute hashes
/// when resizing, at which point only the keys are available.
///
/// Raw entries give mutable access to the keys. This must not be used
/// to modify how the key would compare or hash, as the map will not re-evaluate
/// where the key should go, meaning the keys may become "lost" if their
/// location does not reflect their state. For instance, if you change a key
/// so that the map now contains keys which compare equal, search may start
/// acting erratically, with two keys randomly masking each other. Implementations
/// are free to assume this doesn't happen (within the limits of memory-safety).
#[inline]
pub fn raw_entry_mut(&mut self) -> RawEntryBuilderMut<'_, K, V, H> {
RawEntryBuilderMut { map: self }
}
/// Creates a raw immutable entry builder for the HashMap.
///
/// Raw entries provide the lowest level of control for searching and
/// manipulating a map. They must be manually initialized with a hash and
/// then manually searched.
///
/// This is useful for
/// * Hash memoization
/// * Using a search key that doesn't work with the Borrow trait
/// * Using custom comparison logic without newtype wrappers
///
/// Unless you are in such a situation, higher-level and more foolproof APIs like
/// `get` should be preferred.
///
/// Immutable raw entries have very limited use; you might instead want `raw_entry_mut`.
#[inline]
pub fn raw_entry(&self) -> RawEntryBuilder<'_, K, V, H> {
RawEntryBuilder { map: self }
}
/// Gets the given key's corresponding entry in the map for in-place manipulation.
///
/// # Examples
///
/// ```
/// use ordnung::Map;
///
/// let mut letters = Map::new();
///
/// for ch in "a short treatise on fungi".chars() {
/// let counter = letters.entry(ch).or_insert(0);
/// *counter += 1;
/// }
///
/// assert_eq!(letters[&'s'], 2);
/// assert_eq!(letters[&'t'], 3);
/// assert_eq!(letters[&'u'], 1);
/// assert_eq!(letters.get(&'y'), None);
/// ```
pub fn entry(&mut self, key: K) -> Entry<K, V, H>
where
K: Eq + Clone,
{
for (idx, n) in self.store.iter().enumerate() {
if &key == &n.key {
return Entry::Occupied(OccupiedEntry::new(idx, key, self));
}
}
Entry::Vacant(VacantEntry::new(key, self))
}
}
impl<K, V> IntoIterator for Map<K, V> {
type Item = (K, V);
type IntoIter = IntoIter<K, V>;
#[inline]
fn into_iter(self) -> IntoIter<K, V> {
IntoIter(self)
}
}
/// Consuming iterator
pub struct IntoIter<K, V>(Map<K, V>);
impl<K, V> IntoIter<K, V> {
/// The length of this iterator
pub fn len(&self) -> usize {
self.0.store.len()
}
/// If this iteratoris empty
pub fn is_empty(&self) -> bool {
self.len() == 0
}
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
#[inline]
fn next(&mut self) -> Option<Self::Item> {
loop {
if let Some(n) = self.0.store.pop() {
if let Some(v) = n.value {
return Some((n.key, v));
}
} else {
return None;
}
}
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
let l = self.0.store.len();
(l, Some(l))
}
}
impl<K, Q: ?Sized, V> Index<&Q> for Map<K, V>
where
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash,
{
type Output = V;
/// Returns a reference to the value corresponding to the supplied key.
///
/// # Panics
///
/// Panics if the key is not present in the HashMap.
fn index(&self, key: &Q) -> &V {
self.get(key).expect("Key not found in Map")
}
}
impl<'json, IK, IV, K, V> FromIterator<(IK, IV)> for Map<K, V>
where
IK: Into<K>,
IV: Into<V>,
K: Hash + Eq,
{
fn from_iter<I>(iter: I) -> Self
where
I: IntoIterator<Item = (IK, IV)>,
{
let iter = iter.into_iter();
let mut map = Map::with_capacity(iter.size_hint().0);
for (key, value) in iter {
map.insert(key.into(), value.into());
}
map
}
}
// Because keys can inserted in different order, the safe way to
// compare `Map`s is to iterate over one and check if the other
// has all the same keys.
impl<K, V> PartialEq for Map<K, V>
where
K: Hash + Eq,
V: PartialEq,
{
fn eq(&self, other: &Self) -> bool {
if self.len() != other.len() {
return false;
}
// Faster than .get() since we can avoid hashing
for &Node {
ref value, hash, ..
} in self.store.iter()
{
if let Hit(idx) = other.find(hash) {
if &other.store[idx].value == value {
continue;
}
}
return false;
}
true
}
}
/// An iterator over the entries of a `Map`.
///
/// This struct is created by the [`iter`](./struct.Map.html#method.iter)
/// method on [`Map`](./struct.Map.html). See its documentation for more.
pub struct Iter<'a, K, V> {
inner: slice::Iter<'a, Node<K, V>>,
}
/// A mutable iterator over the entries of a `Map`.
///
/// This struct is created by the [`iter_mut`](./struct.Map.html#method.iter_mut)
/// method on [`Map`](./struct.Map.html). See its documentation for more.
pub struct IterMut<'a, K, V> {
inner: slice::IterMut<'a, Node<K, V>>,
}
impl<K, V> Iter<'_, K, V> {
/// Create an empty iterator that always returns `None`
pub fn empty() -> Self {
Iter { inner: [].iter() }
}
}
impl<'i, K, V> Iterator for Iter<'i, K, V> {
type Item = (&'i K, &'i V);
#[inline]
fn next(&mut self) -> Option<Self::Item> {
while let Some(node) = self.inner.next() {
let value = match node.value {
Some(ref value) => value,
None => continue,
};
return Some((&node.key, value));
}
None
}
}
impl<K, V> DoubleEndedIterator for Iter<'_, K, V> {
#[inline]
fn next_back(&mut self) -> Option<Self::Item> {
while let Some(node) = self.inner.next_back() {
let value = match node.value {
Some(ref value) => value,
None => continue,
};
return Some((&node.key, value));
}
None
}
}
impl<K, V> ExactSizeIterator for Iter<'_, K, V> {
fn len(&self) -> usize {
self.inner.len()
}
}
impl<K, V> IterMut<'_, K, V> {
/// Create an empty iterator that always returns `None`
pub fn empty() -> Self | {
IterMut {
inner: [].iter_mut(),
}
} | identifier_body | |
lib.rs | Hasher::default();
// let mut hasher = rustc_hash::FxHasher::default();
let mut hasher = H::default();
key.hash(&mut hasher);
hasher.finish()
}
/// An iterator visiting all key-value pairs in insertion order.
/// The iterator element type is `(&K, &V)`.
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// map.insert("a", 1);
/// map.insert("b", 2);
/// map.insert("c", 3);
///
/// let entries: Vec<_> = map.iter().collect();
///
/// assert_eq!(
/// entries,
/// &[
/// (&"a", &1),
/// (&"b", &2),
/// (&"c", &3),
/// ],
/// );
/// ```
#[inline]
pub fn iter(&self) -> Iter<K, V> {
Iter {
inner: self.store.iter(),
}
}
/// An iterator visiting all key-value pairs in insertion order, with
/// mutable references to the values. The iterator element type is
/// (&K, &mut V).
///
/// # Examples
///
/// ```rust
/// use ordnung::Map;
///
/// let mut map = Map::new();
/// map.insert("a", 1);
/// map.insert("b", 2);
/// map.insert("c", 3);
///
/// // Update all values
/// for (_, val) in map.iter_mut() {
/// *val *= 2;
/// }
///
/// // Check if values are doubled
/// let entries: Vec<_> = map.iter().collect();
///
/// assert_eq!(
/// entries,
/// &[
/// (&"a", &2),
/// (&"b", &4),
/// (&"c", &6),
/// ],
/// );
/// ```
#[inline]
pub fn iter_mut(&mut self) -> IterMut<K, V> {
IterMut {
inner: self.store.iter_mut(),
}
}
/// Creates a raw entry builder for the HashMap.
///
/// Raw entries provide the lowest level of control for searching and
/// manipulating a map. They must be manually initialized with a hash and
/// then manually searched. After this, insertions into a vacant entry
/// still require an owned key to be provided.
///
/// Raw entries are useful for such exotic situations as:
///
/// * Hash memoization
/// * Deferring the creation of an owned key until it is known to be required
/// * Using a search key that doesn't work with the Borrow trait
/// * Using custom comparison logic without newtype wrappers
///
/// Because raw entries provide much more low-level control, it's much easier
/// to put the HashMap into an inconsistent state which, while memory-safe,
/// will cause the map to produce seemingly random results. Higher-level and
/// more foolproof APIs like `entry` should be preferred when possible.
///
/// In particular, the hash used to initialized the raw entry must still be
/// consistent with the hash of the key that is ultimately stored in the entry.
/// This is because implementations of HashMap may need to recompute hashes
/// when resizing, at which point only the keys are available.
///
/// Raw entries give mutable access to the keys. This must not be used
/// to modify how the key would compare or hash, as the map will not re-evaluate
/// where the key should go, meaning the keys may become "lost" if their
/// location does not reflect their state. For instance, if you change a key
/// so that the map now contains keys which compare equal, search may start
/// acting erratically, with two keys randomly masking each other. Implementations
/// are free to assume this doesn't happen (within the limits of memory-safety).
#[inline]
pub fn raw_entry_mut(&mut self) -> RawEntryBuilderMut<'_, K, V, H> {
RawEntryBuilderMut { map: self }
}
/// Creates a raw immutable entry builder for the HashMap.
///
/// Raw entries provide the lowest level of control for searching and
/// manipulating a map. They must be manually initialized with a hash and
/// then manually searched.
///
/// This is useful for
/// * Hash memoization
/// * Using a search key that doesn't work with the Borrow trait
/// * Using custom comparison logic without newtype wrappers
///
/// Unless you are in such a situation, higher-level and more foolproof APIs like
/// `get` should be preferred.
///
/// Immutable raw entries have very limited use; you might instead want `raw_entry_mut`.
#[inline]
pub fn raw_entry(&self) -> RawEntryBuilder<'_, K, V, H> {
RawEntryBuilder { map: self }
}
/// Gets the given key's corresponding entry in the map for in-place manipulation.
///
/// # Examples
///
/// ```
/// use ordnung::Map;
///
/// let mut letters = Map::new();
///
/// for ch in "a short treatise on fungi".chars() {
/// let counter = letters.entry(ch).or_insert(0);
/// *counter += 1;
/// }
///
/// assert_eq!(letters[&'s'], 2);
/// assert_eq!(letters[&'t'], 3);
/// assert_eq!(letters[&'u'], 1);
/// assert_eq!(letters.get(&'y'), None);
/// ```
pub fn entry(&mut self, key: K) -> Entry<K, V, H>
where
K: Eq + Clone,
{
for (idx, n) in self.store.iter().enumerate() {
if &key == &n.key {
return Entry::Occupied(OccupiedEntry::new(idx, key, self));
}
}
Entry::Vacant(VacantEntry::new(key, self))
}
}
impl<K, V> IntoIterator for Map<K, V> {
type Item = (K, V);
type IntoIter = IntoIter<K, V>;
#[inline]
fn into_iter(self) -> IntoIter<K, V> {
IntoIter(self)
}
}
/// Consuming iterator
pub struct IntoIter<K, V>(Map<K, V>);
impl<K, V> IntoIter<K, V> {
/// The length of this iterator
pub fn len(&self) -> usize {
self.0.store.len()
}
/// If this iteratoris empty
pub fn is_empty(&self) -> bool {
self.len() == 0
}
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
#[inline]
fn next(&mut self) -> Option<Self::Item> {
loop {
if let Some(n) = self.0.store.pop() {
if let Some(v) = n.value {
return Some((n.key, v));
}
} else {
return None;
}
}
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
let l = self.0.store.len();
(l, Some(l))
}
}
impl<K, Q: ?Sized, V> Index<&Q> for Map<K, V>
where
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash,
{
type Output = V;
/// Returns a reference to the value corresponding to the supplied key.
///
/// # Panics
///
/// Panics if the key is not present in the HashMap.
fn index(&self, key: &Q) -> &V {
self.get(key).expect("Key not found in Map")
}
}
impl<'json, IK, IV, K, V> FromIterator<(IK, IV)> for Map<K, V>
where
IK: Into<K>,
IV: Into<V>,
K: Hash + Eq,
{
fn from_iter<I>(iter: I) -> Self
where
I: IntoIterator<Item = (IK, IV)>,
{
let iter = iter.into_iter();
let mut map = Map::with_capacity(iter.size_hint().0);
for (key, value) in iter {
map.insert(key.into(), value.into());
}
map
}
}
// Because keys can inserted in different order, the safe way to
// compare `Map`s is to iterate over one and check if the other
// has all the same keys.
impl<K, V> PartialEq for Map<K, V>
where
K: Hash + Eq,
V: PartialEq,
{
fn eq(&self, other: &Self) -> bool {
if self.len() != other.len() {
return false;
}
// Faster than .get() since we can avoid hashing
for &Node {
ref value, hash, ..
} in self.store.iter()
{
if let Hit(idx) = other.find(hash) {
if &other.store[idx].value == value | {
continue;
} | conditional_block | |
main_api_sentence.py | :param max_seq_length:
:param tokenizer: 初始化后的tokenizer
:param label_list:
:return:
"""
examples = []
for guid, content in enumerate(contents):
examples.append(
InputExample(guid=guid, text_a=content))
features = convert_examples_to_features(examples, label_list, max_seq_length, tokenizer,
output_mode="classification",
cls_token_segment_id=0, pad_token_segment_id=0,reverse_truncate=reverse_truncate)
all_input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long)
all_input_mask = torch.tensor([f.input_mask for f in features], dtype=torch.long)
all_segment_ids = torch.tensor([f.segment_ids for f in features], dtype=torch.long)
all_label_ids = torch.tensor([f.label_id for f in features], dtype=torch.long)
dataset = TensorDataset(all_input_ids, all_input_mask, all_segment_ids, all_label_ids)
return dataset
class TorchAsBertModel(object):
def __init__(self, verbose=0):
self.verbose = verbose
self.label_list = ["消极","中性","积极"]
self.num_labels = len(self.label_list)
# 判断使用的设备
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.n_gpu = torch.cuda.device_count() if torch.cuda.is_available() else 0
# 预测的batch_size大小
self.train_batch_size = 8
# 预测的batch_size大小
self.predict_batch_size = 64
self.max_seq_length = 128
# self.load_predict_model()
self.load_macbert_model()
# self.load_train_model()
self.reverse_truncate = True
def load_train_model(self):
"""
初始化训练的模型
:return:
"""
parser = argparse.ArgumentParser()
args = parser.parse_args()
args.output_encoded_layers = True
args.output_attention_layers = True
args.output_att_score = True
args.output_att_sum = True
self.learning_rate = 2e-05
#学习率 warmup的比例
self.warmup_proportion = 0.1
self.num_train_epochs = 1
#使用的学习率scheduler
self.schedule = 'slanted_triangular'
self.s_opt1 = 30.0
self.s_opt2 = 0.0
self.s_opt3 = 1.0
self.weight_decay_rate = 0.01
#训练多少epcoh保存一次模型
self.ckpt_frequency = 1
#模型和日志保存的位置
self.output_dir = "output_root_dir/train_api"
#梯度累积步数
self.gradient_accumulation_steps = 1
self.args = args
# 解析配置文件, 教师模型和student模型的vocab是不变的
self.vocab_file = "mac_bert_model/vocab.txt"
self.bert_config_file_S = "mac_bert_model/config.json"
self.tuned_checkpoint_S = "mac_bert_model/pytorch_model.bin"
# 加载student的配置文件, 校验最大序列长度小于我们的配置中的序列长度
bert_config_S = BertConfig.from_json_file(self.bert_config_file_S)
# 加载tokenizer
tokenizer = BertTokenizer(vocab_file=self.vocab_file)
# 加载模型
model_S = BertSPCSimple(bert_config_S, num_labels=self.num_labels, args=self.args)
state_dict_S = torch.load(self.tuned_checkpoint_S, map_location=self.device)
state_weight = {k[5:]: v for k, v in state_dict_S.items() if k.startswith('bert.')}
missing_keys, _ = model_S.bert.load_state_dict(state_weight, strict=False)
#验证下参数没有丢失
assert len(missing_keys) == 0
self.train_tokenizer = tokenizer
self.train_model = model_S
logger.info(f"训练模型{self.tuned_checkpoint_S}加载完成")
def load_predict_model(self, model_file="trained_teacher_model/gs3024.pkl"):
parser = argparse.ArgumentParser()
args = parser.parse_args()
args.output_encoded_layers = True
args.output_attention_layers = True
args.output_att_score = True
args.output_att_sum = True
self.args = args
# 解析配置文件, 教师模型和student模型的vocab是不变的
self.vocab_file = "bert_model/vocab.txt"
# 这里是使用的teacher的config和微调后的teacher模型, 也可以换成student的config和蒸馏后的student模型
# student config: config/chinese_bert_config_L4t.json
# distil student model: distil_model/gs8316.pkl
self.bert_config_file_S = "bert_model/config.json"
self.tuned_checkpoint_S = model_file
# 加载student的配置文件, 校验最大序列长度小于我们的配置中的序列长度
bert_config_S = BertConfig.from_json_file(self.bert_config_file_S)
# 加载tokenizer
tokenizer = BertTokenizer(vocab_file=self.vocab_file)
# 加载模型
model_S = BertSPCSimple(bert_config_S, num_labels=self.num_labels, args=self.args)
state_dict_S = torch.load(self.tuned_checkpoint_S, map_location=self.device)
model_S.load_state_dict(state_dict_S)
if self.verbose:
print("模型已加载")
self.predict_tokenizer = tokenizer
self.predict_model = model_S
logger.info(f"预测模型{model_file}加载完成")
def load_macbert_model(self):
parser = argparse.ArgumentParser()
args = parser.parse_args()
args.output_encoded_layers = True
args.output_attention_layers = True
args.output_att_score = True
args.output_att_sum = True
self.args = args
# 解析配置文件, 教师模型和student模型的vocab是不变的
self.vocab_file = "mac_bert_model/vocab.txt"
# 这里是使用的teacher的config和微调后的teacher模型, 也可以换成student的config和蒸馏后的student模型
# student config: config/chinese_bert_config_L4t.json
# distil student model: distil_model/gs8316.pkl
self.bert_config_file_S = "mac_bert_model/config.json"
self.tuned_checkpoint_S = "trained_teacher_model/macbert_2290_cosmetics_weibo.pkl"
# self.tuned_checkpoint_S = "trained_teacher_model/macbert_894_cosmetics.pkl"
# self.tuned_checkpoint_S = "trained_teacher_model/macbert_teacher_max75len_5000.pkl"
# 加载student的配置文件, 校验最大序列长度小于我们的配置中的序列长度
bert_config_S = BertConfig.from_json_file(self.bert_config_file_S)
# 加载tokenizer
tokenizer = BertTokenizer(vocab_file=self.vocab_file)
# 加载模型
model_S = BertSPCSimple(bert_config_S, num_labels=self.num_labels, args=self.args)
state_dict_S = torch.load(self.tuned_checkpoint_S, map_location=self.device)
model_S.load_state_dict(state_dict_S)
if self.verbose:
print("模型已加载")
self.predict_tokenizer = tokenizer
self.predict_model = model_S
logger.info(f"macbert预测模型加载完成")
def compute_metrics(self, predid, labelid):
"""
计算准确度
:return:
"""
return (predid == labelid).mean()
def predict_batch(self, data, model_file=None, print_acc=False):
"""
batch_size数据处理
:param data: 是一个要处理的数据列表[(content,aspect),...,]
:param truncated: 是否要截断数据
:param model_file: 模型文件
:param print_acc: 如果要打印准确率，需要data的第三个位置时label
:return:, 返回格式是 [(predicted_label, predict_score),...]
"""
#如果为None，就不改变加载的模型，否则就改变加载的模型
if model_file:
self.load_predict_model(model_file=model_file)
eval_dataset = load_examples(data, self.max_seq_length, self.predict_tokenizer, self.label_list, self.reverse_truncate)
if self.verbose:
print("评估数据集已加载")
predictids, probability = self.do_predict(model=self.predict_model, eval_dataset=eval_dataset)
if self.verbose:
print(f"预测的结果是: {predictids}, {[self.label_list[id] for id in predictids]}")
#把id变成标签
predict_labels = [self.label_list[r] for r in predictids]
results = list(zip(predict_labels, probability, data))
if print_acc:
label_ids = [self.label_list.index(d[2]) for d in data]
accuracy = self.compute_metrics(np.array(predictids), np.array(label_ids))
return results, accuracy
return results
def do |
def load_examples(contents, max_seq_length, tokenizer, label_list, reverse_truncate=False):
"""
:param contents: eg: [('苹果很好用', '苹果')] 或者 [('苹果很好用', '苹果', '积极')] | random_line_split | |
main_api_sentence.py | = argparse.ArgumentParser()
args = parser.parse_args()
args.output_encoded_layers = True
args.output_attention_layers = True
args.output_att_score = True
args.output_att_sum = True
self.learning_rate = 2e-05
#学习率 warmup的比例
self.warmup_proportion = 0.1
self.num_train_epochs = 1
#使用的学习率scheduler
self.schedule = 'slanted_triangular'
self.s_opt1 = 30.0
self.s_opt2 = 0.0
self.s_opt3 = 1.0
self.weight_decay_rate = 0.01
#训练多少epcoh保存一次模型
self.ckpt_frequency = 1
#模型和日志保存的位置
self.output_dir = "output_root_dir/train_api"
#梯度累积步数
self.gradient_accumulation_steps = 1
self.args = args
# 解析配置文件, 教师模型和student模型的vocab是不变的
self.vocab_file = "mac_bert_model/vocab.txt"
self.bert_config_file_S = "mac_bert_model/config.json"
self.tuned_checkpoint_S = "mac_bert_model/pytorch_model.bin"
# 加载student的配置文件, 校验最大序列长度小于我们的配置中的序列长度
bert_config_S = BertConfig.from_json_file(self.bert_config_file_S)
# 加载tokenizer
tokenizer = BertTokenizer(vocab_file=self.vocab_file)
# 加载模型
model_S = BertSPCSimple(bert_config_S, num_labels=self.num_labels, args=self.args)
state_dict_S = torch.load(self.tuned_checkpoint_S, map_location=self.device)
state_weight = {k[5:]: v for k, v in state_dict_S.items() if k.startswith('bert.')}
missing_keys, _ = model_S.bert.load_state_dict(state_weight, strict=False)
#验证下参数没有丢失
assert len(missing_keys) == 0
self.train_tokenizer = tokenizer
self.train_model = model_S
logger.info(f"训练模型{self.tuned_checkpoint_S}加载完成")
def load_predict_model(self, model_file="trained_teacher_model/gs3024.pkl"):
parser = argparse.ArgumentParser()
args = parser.parse_args()
args.output_encoded_layers = True
args.output_attention_layers = True
args.output_att_score = True
args.output_att_sum = True
self.args = args
# 解析配置文件, 教师模型和student模型的vocab是不变的
self.vocab_file = "bert_model/vocab.txt"
# 这里是使用的teacher的config和微调后的teacher模型, 也可以换成student的config和蒸馏后的student模型
# student config: config/chinese_bert_config_L4t.json
# distil student model: distil_model/gs8316.pkl
self.bert_config_file_S = "bert_model/config.json"
self.tuned_checkpoint_S = model_file
# 加载student的配置文件, 校验最大序列长度小于我们的配置中的序列长度
bert_config_S = BertConfig.from_json_file(self.bert_config_file_S)
# 加载tokenizer
tokenizer = BertTokenizer(vocab_file=self.vocab_file)
# 加载模型
model_S = BertSPCSimple(bert_config_S, num_labels=self.num_labels, args=self.args)
state_dict_S = torch.load(self.tuned_checkpoint_S, map_location=self.device)
model_S.load_state_dict(state_dict_S)
if self.verbose:
print("模型已加载")
self.predict_tokenizer = tokenizer
self.predict_model = model_S
logger.info(f"预测模型{model_file}加载完成")
def load_macbert_model(self):
parser = argparse.ArgumentParser()
args = parser.parse_args()
args.output_encoded_layers = True
args.output_attention_layers = True
args.output_att_score = True
args.output_att_sum = True
self.args = args
# 解析配置文件, 教师模型和student模型的vocab是不变的
self.vocab_file = "mac_bert_model/vocab.txt"
# 这里是使用的teacher的config和微调后的teacher模型, 也可以换成student的config和蒸馏后的student模型
# student config: config/chinese_bert_config_L4t.json
# distil student model: distil_model/gs8316.pkl
self.bert_config_file_S = "mac_bert_model/config.json"
self.tuned_checkpoint_S = "trained_teacher_model/macbert_2290_cosmetics_weibo.pkl"
# self.tuned_checkpoint_S = "trained_teacher_model/macbert_894_cosmetics.pkl"
# self.tuned_checkpoint_S = "trained_teacher_model/macbert_teacher_max75len_5000.pkl"
# 加载student的配置文件, 校验最大序列长度小于我们的配置中的序列长度
bert_config_S = BertConfig.from_json_file(self.bert_config_file_S)
# 加载tokenizer
tokenizer = BertTokenizer(vocab_file=self.vocab_file)
# 加载模型
model_S = BertSPCSimple(bert_config_S, num_labels=self.num_labels, args=self.args)
state_dict_S = torch.load(self.tuned_checkpoint_S, map_location=self.device)
model_S.load_state_dict(state_dict_S)
if self.verbose:
print("模型已加载")
self.predict_tokenizer = tokenizer
self.predict_model = model_S
logger.info(f"macbert预测模型加载完成")
def compute_metrics(self, predid, labelid):
"""
计算准确度
:return:
"""
return (predid == labelid).mean()
def predict_batch(self, data, model_file=None, print_acc=False):
"""
batch_size数据处理
:param data: 是一个要处理的数据列表[(content,aspect),...,]
:param truncated: 是否要截断数据
:param model_file: 模型文件
:param print_acc: 如果要打印准确率，需要data的第三个位置时label
:return:, 返回格式是 [(predicted_label, predict_score),...]
"""
#如果为None，就不改变加载的模型，否则就改变加载的模型
if model_file:
self.load_predict_model(model_file=model_file)
eval_dataset = load_examples(data, self.max_seq_length, self.predict_tokenizer, self.label_list, self.reverse_truncate)
if self.verbose:
print("评估数据集已加载")
predictids, probability = self.do_predict(model=self.predict_model, eval_dataset=eval_dataset)
if self.verbose:
print(f"预测的结果是: {predictids}, {[self.label_list[id] for id in predictids]}")
#把id变成标签
predict_labels = [self.label_list[r] for r in predictids]
results = list(zip(predict_labels, probability, data))
if print_acc:
label_ids = [self.label_list.index(d[2]) for d in data]
accuracy = self.compute_metrics(np.array(predictids), np.array(label_ids))
return results, accuracy
return results
def do_predict(self, model, eval_dataset, step=0):
"""
:param eval_dataset:
:param model 参数必须携带，因为训练的callback会调用评估模型时会传入model
:return: 2个list，一个是预测的id列表，一个是预测的probability列表
"""
# 任务名字
if self.verbose:
print("***** 开始预测 *****")
print(" 样本数 = %d", len(eval_dataset))
print(" Step数 = %d", step)
print(" Batch size = %d", self.predict_batch_size)
# 评估样本
e | dataset, sampler=eval_sampler, batch_size=self.predict_batch_size)
model.eval()
model.to(self.device)
# 起始时间
start_time = time.time()
# 存储预测值
pred_logits = []
for batch in tqdm(eval_dataloader, desc="评估中", disable=True):
input_ids, input_mask, segment_ids, _ = batch
input_ids = input_ids.to(self.device)
input_mask = input_mask.to(self.device)
segment_ids = segment_ids.to(self.device)
with torch.no_grad():
logits = model(input_ids, input_mask, segment_ids)
cpu_logits = logits.detach().cpu()
for i in range(len(cpu_logits)):
pred_logits.append(cpu_logits[i].numpy())
pred_logits = np.array(pred_logits)
# 找到最大的概率label
preds = np.argmax(pred_logits, axis=1)
if self.verbose:
print(f"preds: {preds}")
predictids = preds.tolist()
#获取最大概率的可能性，即分数
pred_logits_softmax = scipy.special.softmax(pred_logits, axis=1)
probability = np.max(pred_logits_softmax, axis=1)
probability = probability.tolist()
cost_time = time.time() - start_time
if self.verbose:
print(
f"--- 评估{len(eval_dataset)}条数据的总耗时是 {cost_time} seconds, 每条耗时 {cost_time / len | val_sampler = SequentialSampler(eval_dataset)
eval_dataloader = DataLoader(eval_ | conditional_block |
main_api_sentence.py | 最大的概率label
preds = np.argmax(pred_logits, axis=1)
if self.verbose:
print(f"preds: {preds}")
predictids = preds.tolist()
#获取最大概率的可能性，即分数
pred_logits_softmax = scipy.special.softmax(pred_logits, axis=1)
probability = np.max(pred_logits_softmax, axis=1)
probability = probability.tolist()
cost_time = time.time() - start_time
if self.verbose:
print(
f"--- 评估{len(eval_dataset)}条数据的总耗时是 {cost_time} seconds, 每条耗时 {cost_time / len(eval_dataset)} seconds ---")
return predictids, probability
def do_train(self, data, truncated=False):
"""
训练模型, 数据集分成2部分，训练集和验证集, 默认比例9:1
:param data: 输入的数据，注意如果做truncated，那么输入的数据为 [(content,aspect,start_idx, end_idx, label),...,]
:param truncated: 是否要截断，截断按照 self.left_max_seq_len, self.right_max_seq_len进行
:return:
"""
if truncated:
data, locations = self.do_truncate_data(data)
train_data_len = int(len(data) * 0.9)
train_data = data[:train_data_len]
eval_data = data[train_data_len:]
train_dataset = load_examples(train_data, self.max_seq_length, self.train_tokenizer, self.label_list, self.reverse_truncate)
eval_dataset = load_examples(eval_data, self.max_seq_length, self.train_tokenizer, self.label_list, self.reverse_truncate)
logger.info("训练数据集已加载,开始训练")
num_train_steps = int(len(train_dataset) / self.train_batch_size) * self.num_train_epochs
forward_batch_size = int(self.train_batch_size / self.gradient_accumulation_steps)
# 开始训练
params = list(self.train_model.named_parameters())
all_trainable_params = divide_parameters(params, lr=self.learning_rate, weight_decay_rate=self.weight_decay_rate)
# 优化器设置
optimizer = BERTAdam(all_trainable_params, lr=self.learning_rate,
warmup=self.warmup_proportion, t_total=num_train_steps, schedule=self.schedule,
s_opt1=self.s_opt1, s_opt2=self.s_opt2, s_opt3=self.s_opt3)
logger.info("***** 开始训练 *****")
logger.info(" 训练样本数是 = %d", len(train_dataset))
logger.info(" 评估样本数是 = %d", len(eval_dataset))
logger.info(" 前向 batch size = %d", forward_batch_size)
logger.info(" 训练的steps = %d", num_train_steps)
########### 训练的配置 ###########
train_config = TrainingConfig(
gradient_accumulation_steps = self.gradient_accumulation_steps,
ckpt_frequency = self.ckpt_frequency,
log_dir = self.output_dir,
output_dir = self.output_dir,
device = self.device)
#初始化trainer，执行监督训练，而不是蒸馏。它可以把model_S模型训练成为teacher模型
distiller = BasicTrainer(train_config = train_config,
model = self.train_model,
adaptor = BertForGLUESimpleAdaptorTraining)
train_sampler = RandomSampler(train_dataset)
#训练的dataloader
train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=forward_batch_size, drop_last=True)
#执行callbakc函数，对eval数据集
callback_func = partial(self.do_predict, eval_dataset=eval_dataset)
with distiller:
#开始训练
distiller.train(optimizer, scheduler=None, dataloader=train_dataloader,
num_epochs=self.num_train_epochs, callback=callback_func)
logger.info(f"训练完成")
return "Done"
@app.route("/api/predict", methods=['POST'])
def predict():
"""
接收POST请求，获取data参数
Args:
test_data: 需要预测的数据，是一个文字列表, [(content,aspect),...,]
Returns: 返回格式是 [(predicted_label, predict_score),...]
"""
jsonres = request.get_json()
test_data = jsonres.get('data', None)
# model = TorchAsBertModel()
results = model.predict_batch(test_data)
logger.info(f"收到的数据是:{test_data}")
logger.info(f"预测的结果是:{results}")
return jsonify(results)
@app.route("/api/predict_truncate", methods=['POST'])
def predict_truncate():
"""
接收POST请求，获取data参数, data信息包含aspect关键在在句子中的位置信息，方便我们截取，我们截取aspect关键字的前后一定的字符作为输入
例如关键字前后的25个字作为sentenceA，aspect关键字作为sentenceB，输入模型
Args:
test_data: 需要预测的数据，是一个文字列表, [(content,aspect,start_idx, end_idx),...,]
如果传过来的数据没有索引，那么需要自己去查找索引 [(content,aspect),...,]
Returns: 返回格式是 [(predicted_label, predict_score),...]
"""
jsonres = request.get_json()
test_data = jsonres.get('data', None)
# model = TorchAsBertModel()
results = model.predict_batch(test_data)
logger.info(f"收到的数据是:{test_data}")
logger.info(f"预测的结果是:{results}")
return jsonify(results)
@app.route("/api/predict_truncate_model", methods=['POST'])
def predict_truncate_model():
"""
使用self.output_dir 下的最新的模型的文件
接收POST请求，获取data参数, data信息包含aspect关键在在句子中的位置信息，方便我们截取，我们截取aspect关键字的前后一定的字符作为输入
例如关键字前后的25个字作为sentenceA，aspect关键字作为sentenceB，输入模型
Args:
test_data: 需要预测的数据，是一个文字列表, [(content,aspect,start_idx, end_idx),...,]
如果传过来的数据没有索引，那么需要自己去查找索引 [(content,aspect),...,]
Returns: 返回格式是 [(predicted_label, predict_score),...]
"""
jsonres = request.get_json()
test_data = jsonres.get('data', None)
# model = TorchAsBertModel()
list_of_files = glob.glob(os.path.join(model.output_dir, "*.pkl"))
latest_model_file = max(list_of_files, key=os.path.getctime)
results = model.predict_batch(test_data, model_file=latest_model_file)
logger.info(f"收到的数据是:{test_data}")
logger.info(f"预测的结果是:{results}")
return jsonify(results)
@app.route("/api/predict_macbert", methods=['POST'])
def predict_macbert():
"""
加载macbert模型，返回预测结果
接收POST请求，获取data参数, data信息包含aspect关键在在句子中的位置信息，方便我们截取，我们截取aspect关键字的前后一定的字符作为输入
例如关键字前后的25个字作为sentenceA，aspect关键字作为sentenceB，输入模型
Args:
test_data: 需要预测的数据，是一个文字列表, [(content,aspect,start_idx, end_idx),...,]
如果传过来的数据没有索引，那么需要自己去查找索引 [(content,aspect),...,]
Returns: 返回格式是 [(predicted_label, predict_score, data),...]
"""
jsonres = request.get_json()
test_data = jsonres.get('data', None)
# model = TorchAsBertModel()
model.load_macbert_model()
results, accuracy = model.predict_batch(test_data, print_acc=True)
logger.info(f"收到的数据是:{test_data}")
logger.info(f"预测的结果是:{results}")
logger.info(f"模型准确率为:{accuracy}")
return jsonify(results)
@app.route("/api/train", methods=['POST'])
def train():
"""
接收data参数，
Args:
data: 训练的数据，是一个文字列表, [(content,aspect,label),...,]
Returns:
"""
jsonres = request.get_json()
data = jsonres.get('data', None)
logger.info(f"收到的数据是:{data}, 进行训练")
# model = TorchAsBertModel()
results = model.do_train(data)
return jsonify(results)
@app.route("/api/train_truncate", methods=['POST'])
def train_truncate():
"""
接收data参数，data信息包含aspect关键在在句子中的位置信息，方便我们截取，我们截取aspect关键字的前后一定的字符作为输入
例如关键字前后的25个字作为sentenceA，aspect关键字作为sentenceB，输入模型
Args:
data: 训练的数据，是一个文字列表, [(content,aspect,start_idx, end_idx, label),...,]
Returns:
"""
jsonres = request.get_json()
data = jsonres.get('data', None)
logger.info(f"收到的数据是:{data}, 进行训练")
# model = TorchAsBertModel()
results = model.do_train(data, truncated=True)
return jsonify(results)
if __name__ == "__main__":
model = TorchAsBertModel()
app.run(host='0.0.0.0', port=5016, debug=False, threaded=True)
| identifier_name | ||
main_api_sentence.py | parser = argparse.ArgumentParser()
args = parser.parse_args()
args.output_encoded_layers = True
args.output_attention_layers = True
args.output_att_score = True
args.output_att_sum = True
self.learning_rate = 2e-05
#学习率 warmup的比例
self.warmup_proportion = 0.1
self.num_train_epochs = 1
#使用的学习率scheduler
self.schedule = 'slanted_triangular'
self.s_opt1 = 30.0
self.s_opt2 = 0.0
self.s_opt3 = 1.0
self.weight_decay_rate = 0.01
#训练多少epcoh保存一次模型
self.ckpt_frequency = 1
#模型和日志保存的位置
self.output_dir = "output_root_dir/train_api"
#梯度累积步数
self.gradient_accumulation_steps = 1
self.args = args
# 解析配置文件, 教师模型和student模型的vocab是不变的
self.vocab_file = "mac_bert_model/vocab.txt"
self.bert_config_file_S = "mac_bert_model/config.json"
self.tuned_checkpoint_S = "mac_bert_model/pytorch_model.bin"
# 加载student的配置文件, 校验最大序列长度小于我们的配置中的序列长度
bert_config_S = BertConfig.from_json_file(self.bert_config_file_S)
# 加载tokenizer
tokenizer = BertTokenizer(vocab_file=self.vocab_file)
# 加载模型
model_S = BertSPCSimple(bert_config_S, num_labels=self.num_labels, args=self.args)
state_dict_S = torch.load(self.tuned_checkpoint_S, map_location=self.device)
state_weight = {k[5:]: v for k, v in state_dict_S.items() if k.startswith('bert.')}
missing_keys, _ = model_S.bert.load_state_dict(state_weight, strict=False)
#验证下参数没有丢失
assert len(missing_keys) == 0
self.train_tokenizer = tokenizer
self.train_model = model_S
logger.info(f"训练模型{self.tuned_checkpoint_S}加载完成")
def load_predict_model(self, model_file="trained_teacher_model/gs3024.pkl"):
parser = argparse.ArgumentParser()
args = parser.parse_args()
args.output_encoded_layers = True
args.output_attention_layers = True
args.output_att_score = True
args.output_att_sum = True
self.args = args
# 解析配置文件, 教师模型和student模型的vocab是不变的
self.vocab_file = "bert_model/vocab.txt"
# 这里是使用的teacher的config和微调后的teacher模型, 也可以换成student的config和蒸馏后的student模型
# student config: config/chinese_bert_config_L4t.json
# distil student model: distil_model/gs8316.pkl
self.bert_config_file_S = "bert_model/config.json"
self.tuned_checkpoint_S = model_file
# 加载student的配置文件, 校验最大序列长度小于我们的配置中的序列长度
bert_config_S = BertConfig.from_json_file(self.bert_config_file_S)
# 加载tokenizer
tokenizer = BertTokenizer(vocab_file=self.vocab_file)
# 加载模型
model_S = BertSPCSimple(bert_config_S, num_labels=self.num_labels, args=self.args)
state_dict_S = torch.load(self.tuned_checkpoint_S, map_location=self.device)
model_S.load_state_dict(state_dict_S)
if self.verbose:
print("模型已加载")
self.predict_tokenizer = tokenizer
self.predict_model = model_S
logger.info(f"预测模型{model_file}加载完成")
def load_macbert_model(self):
parser = argparse.ArgumentParser()
args = parser.parse_args()
args.output_encoded_layers = True
args.output_attention_layers = True
args.output_att_score = True
args.output_att_sum = True
self.args = args
# 解析配置文件, 教师模型和student模型的vocab是不变的
self.vocab_file = "mac_bert_model/vocab.txt"
# 这里是使用的teacher的config和微调后的teacher模型, 也可以换成student的config和蒸馏后的student模型
# student config: config/chinese_bert_config_L4t.json
# distil student model: distil_model/gs8316.pkl
self.bert_config_file_S = "mac_bert_model/config.json"
self.tuned_checkpoint_S = "trained_teacher_model/macbert_2290_cosmetics_weibo.pkl"
# self.tuned_checkpoint_S = "trained_teacher_model/macbert_894_cosmetics.pkl"
# self.tuned_checkpoint_S = "trained_teacher_model/macbert_teacher_max75len_5000.pkl"
# 加载student的配置文件, 校验最大序列长度小于我们的配置中的序列长度
bert_config_S = BertConfig.from_json_file(self.bert_config_file_S)
# 加载tokenizer
tokenizer = BertTokenizer(vocab_file=self.vocab_file)
# 加载模型
model_S = BertSPCSimple(bert_config_S, num_labels=self.num_labels, args=self.args)
state_dict_S = torch.load(self.tuned_checkpoint_S, map_location=self.device)
model_S.load_state_dict(state_dict_S)
if self.verbose:
print("模型已加载")
self.predict_tokenizer = tokenizer
self.predict_model = model_S
logger.info(f"macbert预测模型加载完成")
def compute_metrics(self, predid, labelid):
"""
计算准确度
:return:
"""
return (predid == labelid).mean()
def predict_batch(self, data, model_file=None, print_acc=False):
"""
batch_size数据处理
:param data: 是一个要处理的数据列表[(content,aspect),...,]
:param truncated: 是否要截断数据
:param model_file: 模型文件
:param print_acc: 如果要打印准确率，需要data的第三个位置时label
:return:, 返回格式是 [(predicted_label, predict_score),...]
"""
#如果为None，就不改变加载的模型，否则就改变加载的模型
if model_file:
self.load_predict_model(model_file=model_file)
eval_dataset = load_examples(data, self.max_seq_length, self.predict_tokenizer, self.label_list, self.reverse_truncate)
if self.verbose:
print("评估数据集已加载")
predictids, probability = self.do_predict(model=self.predict_model, eval_dataset=eval_dataset)
if self.verbose:
print(f"预测的结果是: {predictids}, {[self.label_list[id] for id in predictids]}")
#把id变成标签
predict_labels = [self.label_list[r] for r in predictids]
results = list(zip(predict_labels, probability, data))
if print_acc:
label_ids = [self.label_list.index(d[2]) for d in data]
accuracy = self.compute_metrics(np.array(predictids), np.array(label_ids))
return results, accuracy
return results
def do_predict(self, model, eval_dataset, step=0):
"""
:param eval_dataset:
:param model 参数必须携带，因为训练的callback会调用评估模型时会传入model
:return: 2个list，一个是预测的id列表，一个是预测的probability列表
"""
# 任务名字
if self.verbose:
print("***** 开始预测 *****")
print(" 样本数 = %d", len(eval_dataset))
print(" Step数 = %d", step)
print(" Batch size = %d", self.predict_batch_size)
# 评估样本
eval_sampler = SequentialSampler(eval_dataset)
eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=self.predict_batch_size)
model.eval()
model.to(self.device)
# 起始时间
start_time = time.time()
# 存储预测值
pred_logits = []
for batch in tqdm(eval_dataloader, desc="评估中", disable=True):
input_ids, input_mask, segment_ids, _ = batch
input_ids = input_ids.to(self.device)
input_mask = input_mask.to(self.device)
segment_ids | print(
f"--- 评估{len(eval_dataset)}条数据的总耗时是 {cost_time} seconds, 每条耗时 {cost_time / len(eval | = segment_ids.to(self.device)
with torch.no_grad():
logits = model(input_ids, input_mask, segment_ids)
cpu_logits = logits.detach().cpu()
for i in range(len(cpu_logits)):
pred_logits.append(cpu_logits[i].numpy())
pred_logits = np.array(pred_logits)
# 找到最大的概率label
preds = np.argmax(pred_logits, axis=1)
if self.verbose:
print(f"preds: {preds}")
predictids = preds.tolist()
#获取最大概率的可能性，即分数
pred_logits_softmax = scipy.special.softmax(pred_logits, axis=1)
probability = np.max(pred_logits_softmax, axis=1)
probability = probability.tolist()
cost_time = time.time() - start_time
if self.verbose: | identifier_body |
tf_train_loop.py | df_baseline = df_baseline.combine_first(truepos)
else:
df_baseline['latDeg'] = df_baseline['baseLatDeg']
df_baseline['lngDeg'] = df_baseline['baseLngDeg']
df_baseline['heightAboveWgs84EllipsoidM'] = df_baseline['baseHeightAboveWgs84EllipsoidM']
baseline_times = []
baseline_ecef_coords = []
gt_ecef_coords = []
for timemili, row in df_baseline.iterrows():
latbl, lonbl, altbl = float(row['baseLatDeg']),float(row['baseLngDeg']),float(row['baseHeightAboveWgs84EllipsoidM'])
baseline_times.append(timemili)
baseline_ecef_coords.append(np.array(pm.geodetic2ecef(latbl,lonbl,altbl, deg = True)))
latbl, lonbl, altbl = float(row['latDeg']),float(row['lngDeg']),float(row['heightAboveWgs84EllipsoidM'] - 61)
gt_ecef_coords.append(np.array(pm.geodetic2ecef(latbl,lonbl,altbl, deg = True)))
#baseline_ecef_coords = gt_ecef_coords.copy()
mat_local = np.zeros((3,3))
mat_local[2] = baseline_ecef_coords[0]/np.linalg.norm(baseline_ecef_coords[0], axis = -1)
mat_local[0] = np.array([0,0,1])
mat_local[0] = mat_local[0] - mat_local[2]*np.sum(mat_local[2]*mat_local[0])
mat_local[0] = mat_local[0]/np.linalg.norm(mat_local[0], axis = -1)
mat_local[1] = np.cross(mat_local[0], mat_local[2])
mat_local = np.transpose(mat_local)
#mat_local = np.eye(3)
gt_ecef_coords = np.array(gt_ecef_coords)
baseline_times = np.array(baseline_times)
baseline_ecef_coords = np.array(baseline_ecef_coords)
gt_ecef_coords = np.matmul(gt_ecef_coords,mat_local)
timeshift = 3657*24*60*60
datetimenow = int(baseline_times[0])//1000+timeshift
datetimenow = datetime.datetime.utcfromtimestamp(datetimenow)
slac_file = loadSlac(datetimenow)
slac = myLoadRinexPrevdoIndexed(slac_file)
slac_coords = np.array(myLoadRinex(slac_file).position)
slac_times = np.array([r[0] for r in slac])
slac_values = np.array([r[1] for r in slac])
phone_models = []
phone_times = []
constellations = ['GPS', 'GLONASS', 'BEIDOU','GALILEO']
dog = AstroDog(valid_const=constellations, pull_orbit=True)
phones = {}
phone_names = []
max_time = min_time = 0
bufx = []
bufy = []
bufz = []
window = 8
for i in range(len(baseline_ecef_coords)):
bufx.append(baseline_ecef_coords[i,0])
bufy.append(baseline_ecef_coords[i,1])
bufz.append(baseline_ecef_coords[i,2])
if len(bufx) > window*2+1:
bufx = bufx[1:]
bufy = bufy[1:]
bufz = bufz[1:]
if i >= window:
baseline_ecef_coords[i-window,0] = sorted(bufx)[len(bufx)//2]
baseline_ecef_coords[i-window,1] = sorted(bufy)[len(bufy)//2]
baseline_ecef_coords[i-window,2] = sorted(bufz)[len(bufz)//2]
#baseline_ecef_coords = scipy.signal.medfilt(baseline_ecef_coords, [1025,1])
baseline_ecef_coords += np.random.normal(0.,20.,baseline_ecef_coords.shape)
try:
with open(folder + "/" + track + "/export.dat", 'rb') as f:
data_file = pickle.load(f)
except:
data_file = None
for phonepath in phone_glob:
phone = phonepath
phones[phone] = len(phones)
phone_names.append(phone)
print(phone, end=' ')
if False: #data_file != None:
model, times = tf_phone_model.createGpsPhoneModelFromDataFile(data_file,phone,{ 'times':baseline_times, 'values':baseline_ecef_coords}, mat_local)
else:
try:
df_raw = pd.read_csv(folder + "/" + track + "/" + phone + "/" + phone + "_raw.csv")
except:
logs = read_log.gnss_log_to_dataframes(folder + "/" + track + "/" + phone + "/" + phone + "_GnssLog.txt")
df_raw = logs['Raw']
df_raw.to_csv(folder + "/" + track + "/" + phone + "/" + phone + "_raw.csv")
model, times = tf_phone_model.createGpsPhoneModel(df_raw,{ 'times':baseline_times, 'values':baseline_ecef_coords},mat_local,dog, { 'times':slac_times, 'values':slac_values, 'coords':slac_coords})
phone_models.append(model)
phone_times.append(times)
if min_time == 0 or min_time > times[0]:
min_time = times[0]
if max_time == 0 or max_time < times[-1]:
max_time = times[-1]
model_track, track_model_error, num_measures, start_nanos, time_tick = tf_phone_model.createTrackModel(min_time,max_time, { 'times':baseline_times, 'values':baseline_ecef_coords}, mat_local)
istart = np.searchsorted(baseline_times, start_nanos*1e-6)
iend = np.searchsorted(baseline_times, (start_nanos+time_tick*num_measures)*1e-6)
baseline_ecef_coords = baseline_ecef_coords[istart:iend]
baseline_times = baseline_times[istart:iend]
gt_ecef_coords = gt_ecef_coords[istart:iend]
track_input = np.arange(num_measures)
track_input = np.reshape(track_input,(-1,1))
def kernel_init(shape, dtype=None, partition_info=None):
kernel = np.zeros(shape)
kernel[:,0,0] = np.array([-1,1]).astype(np.float64)
return kernel
derivative = tf.keras.layers.Conv1D(1,2,use_bias=False,kernel_initializer=kernel_init, dtype = tf.float64)
def kernel_init_epoch(shape, dtype=None, partition_info=None):
kernel = np.zeros(shape).astype(np.float64)
kin = np.zeros((3)).astype(np.float64)
kin[0] = -1
kin[-1] = 1
kernel[:,0,0] = kin
return kernel
derivative_epoch = tf.keras.layers.Conv1D(1,3,use_bias=False,kernel_initializer=kernel_init_epoch, dtype = tf.float64)
@tf.function
def train_step_gnss(optimizer, physics):
for _ in range(16):
with tf.GradientTape(persistent=True) as tape:
total_loss_psevdo = 0
total_loss_delta = 0
accs_loss_large = 0
accs_loss_small = 0
speed_loss_small = 0
for i in range(len(phone_models)):
poses = model_track(phone_times[i], training=True)
poses = tf.reshape(poses,(1,-1,3))
psevdo_loss,delta_loss,delta_dif, psev_error = phone_models[i](poses, training=True)
total_loss_psevdo += psevdo_loss/10
total_loss_delta += delta_loss*2
total_loss = total_loss_delta +total_loss_psevdo
poses = track_model_error(track_input, training=True)
poses = tf.reshape(poses,(-1, 3))
poses | phone_glob = next(os.walk(folder+"/"+track))[1]
print(folder, track, end=' ')
phones = {}
phone_names = []
if "train" in folder:
df_baseline = pd.read_csv("data/baseline_locations_train.csv")
else:
df_baseline = pd.read_csv("data/baseline_locations_test.csv")
df_baseline = df_baseline[df_baseline['collectionName'] == track]
df_baseline.rename(columns = {'latDeg':'baseLatDeg', 'lngDeg':'baseLngDeg', 'heightAboveWgs84EllipsoidM':'baseHeightAboveWgs84EllipsoidM'}, inplace = True)
df_baseline.set_index('millisSinceGpsEpoch', inplace = True)
df_baseline = df_baseline[~df_baseline.index.duplicated(keep='first')]
df_baseline.sort_index(inplace=True)
if "train" in folder:
for phonepath in phone_glob:
truepos = pd.read_csv(folder+"/" + track + "/" + phonepath + "/ground_truth.csv")
truepos.set_index('millisSinceGpsEpoch', inplace = True) | identifier_body | |
tf_train_loop.py | df_baseline = df_baseline.combine_first(truepos)
else:
df_baseline['latDeg'] = df_baseline['baseLatDeg']
df_baseline['lngDeg'] = df_baseline['baseLngDeg']
df_baseline['heightAboveWgs84EllipsoidM'] = df_baseline['baseHeightAboveWgs84EllipsoidM']
baseline_times = []
baseline_ecef_coords = []
gt_ecef_coords = []
for timemili, row in df_baseline.iterrows():
latbl, lonbl, altbl = float(row['baseLatDeg']),float(row['baseLngDeg']),float(row['baseHeightAboveWgs84EllipsoidM'])
baseline_times.append(timemili)
baseline_ecef_coords.append(np.array(pm.geodetic2ecef(latbl,lonbl,altbl, deg = True)))
latbl, lonbl, altbl = float(row['latDeg']),float(row['lngDeg']),float(row['heightAboveWgs84EllipsoidM'] - 61)
gt_ecef_coords.append(np.array(pm.geodetic2ecef(latbl,lonbl,altbl, deg = True)))
#baseline_ecef_coords = gt_ecef_coords.copy()
mat_local = np.zeros((3,3))
mat_local[2] = baseline_ecef_coords[0]/np.linalg.norm(baseline_ecef_coords[0], axis = -1)
mat_local[0] = np.array([0,0,1])
mat_local[0] = mat_local[0] - mat_local[2]*np.sum(mat_local[2]*mat_local[0])
mat_local[0] = mat_local[0]/np.linalg.norm(mat_local[0], axis = -1)
mat_local[1] = np.cross(mat_local[0], mat_local[2])
mat_local = np.transpose(mat_local)
#mat_local = np.eye(3)
gt_ecef_coords = np.array(gt_ecef_coords)
baseline_times = np.array(baseline_times)
baseline_ecef_coords = np.array(baseline_ecef_coords)
gt_ecef_coords = np.matmul(gt_ecef_coords,mat_local)
timeshift = 3657*24*60*60
datetimenow = int(baseline_times[0])//1000+timeshift
datetimenow = datetime.datetime.utcfromtimestamp(datetimenow)
slac_file = loadSlac(datetimenow)
slac = myLoadRinexPrevdoIndexed(slac_file)
slac_coords = np.array(myLoadRinex(slac_file).position)
slac_times = np.array([r[0] for r in slac])
slac_values = np.array([r[1] for r in slac])
phone_models = []
phone_times = []
constellations = ['GPS', 'GLONASS', 'BEIDOU','GALILEO']
dog = AstroDog(valid_const=constellations, pull_orbit=True)
phones = {}
phone_names = []
max_time = min_time = 0
bufx = []
bufy = []
bufz = []
window = 8
for i in range(len(baseline_ecef_coords)):
bufx.append(baseline_ecef_coords[i,0])
bufy.append(baseline_ecef_coords[i,1])
bufz.append(baseline_ecef_coords[i,2])
if len(bufx) > window*2+1:
bufx = bufx[1:]
bufy = bufy[1:]
bufz = bufz[1:]
if i >= window:
baseline_ecef_coords[i-window,0] = sorted(bufx)[len(bufx)//2]
baseline_ecef_coords[i-window,1] = sorted(bufy)[len(bufy)//2]
baseline_ecef_coords[i-window,2] = sorted(bufz)[len(bufz)//2]
#baseline_ecef_coords = scipy.signal.medfilt(baseline_ecef_coords, [1025,1])
baseline_ecef_coords += np.random.normal(0.,20.,baseline_ecef_coords.shape)
try:
with open(folder + "/" + track + "/export.dat", 'rb') as f:
data_file = pickle.load(f)
except:
data_file = None
for phonepath in phone_glob:
phone = phonepath
phones[phone] = len(phones)
phone_names.append(phone)
print(phone, end=' ')
if False: #data_file != None:
model, times = tf_phone_model.createGpsPhoneModelFromDataFile(data_file,phone,{ 'times':baseline_times, 'values':baseline_ecef_coords}, mat_local)
else:
try:
df_raw = pd.read_csv(folder + "/" + track + "/" + phone + "/" + phone + "_raw.csv")
except:
logs = read_log.gnss_log_to_dataframes(folder + "/" + track + "/" + phone + "/" + phone + "_GnssLog.txt")
df_raw = logs['Raw']
df_raw.to_csv(folder + "/" + track + "/" + phone + "/" + phone + "_raw.csv")
model, times = tf_phone_model.createGpsPhoneModel(df_raw,{ 'times':baseline_times, 'values':baseline_ecef_coords},mat_local,dog, { 'times':slac_times, 'values':slac_values, 'coords':slac_coords})
phone_models.append(model)
phone_times.append(times)
if min_time == 0 or min_time > times[0]:
min_time = times[0]
if max_time == 0 or max_time < times[-1]:
max_time = times[-1]
model_track, track_model_error, num_measures, start_nanos, time_tick = tf_phone_model.createTrackModel(min_time,max_time, { 'times':baseline_times, 'values':baseline_ecef_coords}, mat_local)
istart = np.searchsorted(baseline_times, start_nanos*1e-6)
iend = np.searchsorted(baseline_times, (start_nanos+time_tick*num_measures)*1e-6)
baseline_ecef_coords = baseline_ecef_coords[istart:iend]
baseline_times = baseline_times[istart:iend]
gt_ecef_coords = gt_ecef_coords[istart:iend]
track_input = np.arange(num_measures)
track_input = np.reshape(track_input,(-1,1))
def kernel_init(shape, dtype=None, partition_info=None):
kernel = np.zeros(shape)
kernel[:,0,0] = np.array([-1,1]).astype(np.float64)
return kernel
derivative = tf.keras.layers.Conv1D(1,2,use_bias=False,kernel_initializer=kernel_init, dtype = tf.float64)
def kernel_init_epoch(shape, dtype=None, partition_info=None):
kernel = np.zeros(shape).astype(np.float64)
kin = np.zeros((3)).astype(np.float64)
kin[0] = -1
kin[-1] = 1
kernel[:,0,0] = kin
return kernel
derivative_epoch = tf.keras.layers.Conv1D(1,3,use_bias=False,kernel_initializer=kernel_init_epoch, dtype = tf.float64)
@tf.function
def train_step_gnss(optimizer, physics):
for _ in range(16):
with tf.GradientTape(persistent=True) as tape:
total_loss_psevdo = 0
total_loss_delta = 0
accs_loss_large = 0
accs_loss_small = 0
speed_loss_small = 0
for i in range(len(phone_models)):
poses = model_track(phone_times[i], training=True)
poses = tf.reshape(poses,(1,-1,3))
psevdo_loss,delta_loss,delta_dif, psev_error = phone_models[i](poses, training=True)
total_loss_psevdo += psevdo_loss/10
total_loss_delta += delta_loss*2
total_loss = total_loss_delta +total_loss_psevdo
poses = track_model_error(track_input, training=True)
poses = tf.reshape(poses,(-1, 3))
poses_batch = tf.transpose(poses)
poses_batch = tf.expand_dims(poses_batch, axis=-1)
speed = derivative_epoch(poses_batch)
speed = tf.pad(speed,[[0,0],[0,1], [0,0]])
shift1 = derivative(poses_batch) |
shift_loss = tf.reduce_mean(tf.abs(shift1-shift2)) * 0.01
accel = derivative(speed)
accel = tf.squeeze(accel)
accel = tf.transpose(accel)
accs_loss_large = tf.reduce_mean(tf.nn.relu(tf.abs(accel) - 4))
accs_loss_small = tf.reduce_mean(tf.abs(accel)) * 0.01
speed_loss_small = tf.reduce_mean(tf.abs(speed[2])) * 0.01 + shift_loss
'''
speed = (poses[3:] - poses[:-3])
speed_loss_small += tf.reduce_mean(tf.abs(poses[2:-1] - poses[1:-2]-speed/3))*0.01
accs = speed[1:] - speed | shift2 = speed*0.5 | random_line_split |
tf_train_loop.py | data_file = pickle.load(f)
except:
data_file = None
for phonepath in phone_glob:
phone = phonepath
phones[phone] = len(phones)
phone_names.append(phone)
print(phone, end=' ')
if False: #data_file != None:
model, times = tf_phone_model.createGpsPhoneModelFromDataFile(data_file,phone,{ 'times':baseline_times, 'values':baseline_ecef_coords}, mat_local)
else:
try:
df_raw = pd.read_csv(folder + "/" + track + "/" + phone + "/" + phone + "_raw.csv")
except:
logs = read_log.gnss_log_to_dataframes(folder + "/" + track + "/" + phone + "/" + phone + "_GnssLog.txt")
df_raw = logs['Raw']
df_raw.to_csv(folder + "/" + track + "/" + phone + "/" + phone + "_raw.csv")
model, times = tf_phone_model.createGpsPhoneModel(df_raw,{ 'times':baseline_times, 'values':baseline_ecef_coords},mat_local,dog, { 'times':slac_times, 'values':slac_values, 'coords':slac_coords})
phone_models.append(model)
phone_times.append(times)
if min_time == 0 or min_time > times[0]:
min_time = times[0]
if max_time == 0 or max_time < times[-1]:
max_time = times[-1]
model_track, track_model_error, num_measures, start_nanos, time_tick = tf_phone_model.createTrackModel(min_time,max_time, { 'times':baseline_times, 'values':baseline_ecef_coords}, mat_local)
istart = np.searchsorted(baseline_times, start_nanos*1e-6)
iend = np.searchsorted(baseline_times, (start_nanos+time_tick*num_measures)*1e-6)
baseline_ecef_coords = baseline_ecef_coords[istart:iend]
baseline_times = baseline_times[istart:iend]
gt_ecef_coords = gt_ecef_coords[istart:iend]
track_input = np.arange(num_measures)
track_input = np.reshape(track_input,(-1,1))
def kernel_init(shape, dtype=None, partition_info=None):
kernel = np.zeros(shape)
kernel[:,0,0] = np.array([-1,1]).astype(np.float64)
return kernel
derivative = tf.keras.layers.Conv1D(1,2,use_bias=False,kernel_initializer=kernel_init, dtype = tf.float64)
def kernel_init_epoch(shape, dtype=None, partition_info=None):
kernel = np.zeros(shape).astype(np.float64)
kin = np.zeros((3)).astype(np.float64)
kin[0] = -1
kin[-1] = 1
kernel[:,0,0] = kin
return kernel
derivative_epoch = tf.keras.layers.Conv1D(1,3,use_bias=False,kernel_initializer=kernel_init_epoch, dtype = tf.float64)
@tf.function
def train_step_gnss(optimizer, physics):
for _ in range(16):
with tf.GradientTape(persistent=True) as tape:
total_loss_psevdo = 0
total_loss_delta = 0
accs_loss_large = 0
accs_loss_small = 0
speed_loss_small = 0
for i in range(len(phone_models)):
poses = model_track(phone_times[i], training=True)
poses = tf.reshape(poses,(1,-1,3))
psevdo_loss,delta_loss,delta_dif, psev_error = phone_models[i](poses, training=True)
total_loss_psevdo += psevdo_loss/10
total_loss_delta += delta_loss*2
total_loss = total_loss_delta +total_loss_psevdo
poses = track_model_error(track_input, training=True)
poses = tf.reshape(poses,(-1, 3))
poses_batch = tf.transpose(poses)
poses_batch = tf.expand_dims(poses_batch, axis=-1)
speed = derivative_epoch(poses_batch)
speed = tf.pad(speed,[[0,0],[0,1], [0,0]])
shift1 = derivative(poses_batch)
shift2 = speed*0.5
shift_loss = tf.reduce_mean(tf.abs(shift1-shift2)) * 0.01
accel = derivative(speed)
accel = tf.squeeze(accel)
accel = tf.transpose(accel)
accs_loss_large = tf.reduce_mean(tf.nn.relu(tf.abs(accel) - 4))
accs_loss_small = tf.reduce_mean(tf.abs(accel)) * 0.01
speed_loss_small = tf.reduce_mean(tf.abs(speed[2])) * 0.01 + shift_loss
'''
speed = (poses[3:] - poses[:-3])
speed_loss_small += tf.reduce_mean(tf.abs(poses[2:-1] - poses[1:-2]-speed/3))*0.01
accs = speed[1:] - speed[:-1]
acs2 = tf.linalg.norm(tf.abs(accs)+1.e-7, axis = -1)
accs_loss_small = tf.reduce_mean(acs2) / 100
accs_loss_large = tf.reduce_mean(tf.nn.relu(acs2-5))
'''
total_loss += (accs_loss_small + accs_loss_large + speed_loss_small)*5
for i in range(len(phone_models)):
grads = tape.gradient(total_loss, phone_models[i].trainable_weights)
optimizer.apply_gradients(zip(grads, phone_models[i].trainable_weights))
grads = tape.gradient(total_loss, model_track.trainable_weights)
optimizer.apply_gradients(zip(grads, model_track.trainable_weights))
grads = tape.gradient(total_loss, track_model_error.trainable_weights)
optimizer.apply_gradients(zip(grads, track_model_error.trainable_weights))
del tape
return total_loss, accs_loss_small, accs_loss_large, speed_loss_small, total_loss_psevdo, total_loss_delta, delta_dif, poses, psev_error
lr = 0.5
#optimizer = keras.optimizers.SGD(learning_rate=100., nesterov=True, momentum=0.5)
#optimizer = keras.optimizers.Adam(learning_rate=0.5)
optimizer = keras.optimizers.Adam(learning_rate=0.01)#, epsilon= 0.0001)
#optimizer = keras.optimizers.SGD(lr=0.01, momentum=0.9, clipvalue=100. )
for step in range(32*60):
total_loss, accs_loss_small, accs_loss_large, speed_loss_small = 0,0,0,0
physics = 0
for _ in range(32):
total_loss, accs_loss_small, accs_loss_large, speed_loss_small, total_loss_psevdo, total_loss_delta, delta_dif, poses, psev_error = train_step_gnss(optimizer, physics)
pred_pos = model_track(baseline_times*1000000).numpy()
poses = poses.numpy()
psev_error = psev_error.numpy()
psev_error = psev_error[np.abs(psev_error) > 0]
percents_good_psev = np.sum(np.abs(psev_error) < 1)*100/len(psev_error)
shift = pred_pos - gt_ecef_coords
meanshift = np.mean(shift,axis=0,keepdims=True)
shift = shift - meanshift
err3d = np.mean(np.linalg.norm(shift,axis = -1))
dist_2d = np.linalg.norm(shift[:,:2],axis = -1)
err2d = np.mean(dist_2d)
dist_2d = np.sort(dist_2d)
err50 = dist_2d[len(dist_2d)//2]
err95 = dist_2d[len(dist_2d)*95//100]
delta_dif = delta_dif.numpy()
delta_dif = delta_dif[np.abs(delta_dif) > 0]
percents_good = np.sum(np.abs(delta_dif) < 0.1)*100/len(delta_dif)
print( "Training loss at step %d (%.2f (%.2f),%.2f,%.2f,%.2f,%.4f): %.4f (%.2f),%.4f (%.2f),%.4f,%.4f,%.4f lr %.4f" % (step, err3d, np.linalg.norm(meanshift[0,:2]), err2d, err50, err95, (err50+err95)/2, float(total_loss_psevdo), percents_good_psev, float(total_loss_delta),percents_good,float(accs_loss_large),float(accs_loss_small), float(speed_loss_small), float(lr)), end='\r')
if(step % 32 == 0):
lr *= 0.90
optimizer.learning_rate = lr
if(step > 32):
| physics = 1. | conditional_block | |
tf_train_loop.py | _baseline = df_baseline.combine_first(truepos)
else:
df_baseline['latDeg'] = df_baseline['baseLatDeg']
df_baseline['lngDeg'] = df_baseline['baseLngDeg']
df_baseline['heightAboveWgs84EllipsoidM'] = df_baseline['baseHeightAboveWgs84EllipsoidM']
baseline_times = []
baseline_ecef_coords = []
gt_ecef_coords = []
for timemili, row in df_baseline.iterrows():
latbl, lonbl, altbl = float(row['baseLatDeg']),float(row['baseLngDeg']),float(row['baseHeightAboveWgs84EllipsoidM'])
baseline_times.append(timemili)
baseline_ecef_coords.append(np.array(pm.geodetic2ecef(latbl,lonbl,altbl, deg = True)))
latbl, lonbl, altbl = float(row['latDeg']),float(row['lngDeg']),float(row['heightAboveWgs84EllipsoidM'] - 61)
gt_ecef_coords.append(np.array(pm.geodetic2ecef(latbl,lonbl,altbl, deg = True)))
#baseline_ecef_coords = gt_ecef_coords.copy()
mat_local = np.zeros((3,3))
mat_local[2] = baseline_ecef_coords[0]/np.linalg.norm(baseline_ecef_coords[0], axis = -1)
mat_local[0] = np.array([0,0,1])
mat_local[0] = mat_local[0] - mat_local[2]*np.sum(mat_local[2]*mat_local[0])
mat_local[0] = mat_local[0]/np.linalg.norm(mat_local[0], axis = -1)
mat_local[1] = np.cross(mat_local[0], mat_local[2])
mat_local = np.transpose(mat_local)
#mat_local = np.eye(3)
gt_ecef_coords = np.array(gt_ecef_coords)
baseline_times = np.array(baseline_times)
baseline_ecef_coords = np.array(baseline_ecef_coords)
gt_ecef_coords = np.matmul(gt_ecef_coords,mat_local)
timeshift = 3657*24*60*60
datetimenow = int(baseline_times[0])//1000+timeshift
datetimenow = datetime.datetime.utcfromtimestamp(datetimenow)
slac_file = loadSlac(datetimenow)
slac = myLoadRinexPrevdoIndexed(slac_file)
slac_coords = np.array(myLoadRinex(slac_file).position)
slac_times = np.array([r[0] for r in slac])
slac_values = np.array([r[1] for r in slac])
phone_models = []
phone_times = []
constellations = ['GPS', 'GLONASS', 'BEIDOU','GALILEO']
dog = AstroDog(valid_const=constellations, pull_orbit=True)
phones = {}
phone_names = []
max_time = min_time = 0
bufx = []
bufy = []
bufz = []
window = 8
for i in range(len(baseline_ecef_coords)):
bufx.append(baseline_ecef_coords[i,0])
bufy.append(baseline_ecef_coords[i,1])
bufz.append(baseline_ecef_coords[i,2])
if len(bufx) > window*2+1:
bufx = bufx[1:]
bufy = bufy[1:]
bufz = bufz[1:]
if i >= window:
baseline_ecef_coords[i-window,0] = sorted(bufx)[len(bufx)//2]
baseline_ecef_coords[i-window,1] = sorted(bufy)[len(bufy)//2]
baseline_ecef_coords[i-window,2] = sorted(bufz)[len(bufz)//2]
#baseline_ecef_coords = scipy.signal.medfilt(baseline_ecef_coords, [1025,1])
baseline_ecef_coords += np.random.normal(0.,20.,baseline_ecef_coords.shape)
try:
with open(folder + "/" + track + "/export.dat", 'rb') as f:
data_file = pickle.load(f)
except:
data_file = None
for phonepath in phone_glob:
phone = phonepath
phones[phone] = len(phones)
phone_names.append(phone)
print(phone, end=' ')
if False: #data_file != None:
model, times = tf_phone_model.createGpsPhoneModelFromDataFile(data_file,phone,{ 'times':baseline_times, 'values':baseline_ecef_coords}, mat_local)
else:
try:
df_raw = pd.read_csv(folder + "/" + track + "/" + phone + "/" + phone + "_raw.csv")
except:
logs = read_log.gnss_log_to_dataframes(folder + "/" + track + "/" + phone + "/" + phone + "_GnssLog.txt")
df_raw = logs['Raw']
df_raw.to_csv(folder + "/" + track + "/" + phone + "/" + phone + "_raw.csv")
model, times = tf_phone_model.createGpsPhoneModel(df_raw,{ 'times':baseline_times, 'values':baseline_ecef_coords},mat_local,dog, { 'times':slac_times, 'values':slac_values, 'coords':slac_coords})
phone_models.append(model)
phone_times.append(times)
if min_time == 0 or min_time > times[0]:
min_time = times[0]
if max_time == 0 or max_time < times[-1]:
max_time = times[-1]
model_track, track_model_error, num_measures, start_nanos, time_tick = tf_phone_model.createTrackModel(min_time,max_time, { 'times':baseline_times, 'values':baseline_ecef_coords}, mat_local)
istart = np.searchsorted(baseline_times, start_nanos*1e-6)
iend = np.searchsorted(baseline_times, (start_nanos+time_tick*num_measures)*1e-6)
baseline_ecef_coords = baseline_ecef_coords[istart:iend]
baseline_times = baseline_times[istart:iend]
gt_ecef_coords = gt_ecef_coords[istart:iend]
track_input = np.arange(num_measures)
track_input = np.reshape(track_input,(-1,1))
def kernel_init(shape, dtype=None, partition_info=None):
kernel = np.zeros(shape)
kernel[:,0,0] = np.array([-1,1]).astype(np.float64)
return kernel
derivative = tf.keras.layers.Conv1D(1,2,use_bias=False,kernel_initializer=kernel_init, dtype = tf.float64)
def kernel_init_epoch(shape, dtype=None, partition_info=None):
kernel = np.zeros(shape).astype(np.float64)
kin = np.zeros((3)).astype(np.float64)
kin[0] = -1
kin[-1] = 1
kernel[:,0,0] = kin
return kernel
derivative_epoch = tf.keras.layers.Conv1D(1,3,use_bias=False,kernel_initializer=kernel_init_epoch, dtype = tf.float64)
@tf.function
def | (optimizer, physics):
for _ in range(16):
with tf.GradientTape(persistent=True) as tape:
total_loss_psevdo = 0
total_loss_delta = 0
accs_loss_large = 0
accs_loss_small = 0
speed_loss_small = 0
for i in range(len(phone_models)):
poses = model_track(phone_times[i], training=True)
poses = tf.reshape(poses,(1,-1,3))
psevdo_loss,delta_loss,delta_dif, psev_error = phone_models[i](poses, training=True)
total_loss_psevdo += psevdo_loss/10
total_loss_delta += delta_loss*2
total_loss = total_loss_delta +total_loss_psevdo
poses = track_model_error(track_input, training=True)
poses = tf.reshape(poses,(-1, 3))
poses_batch = tf.transpose(poses)
poses_batch = tf.expand_dims(poses_batch, axis=-1)
speed = derivative_epoch(poses_batch)
speed = tf.pad(speed,[[0,0],[0,1], [0,0]])
shift1 = derivative(poses_batch)
shift2 = speed*0.5
shift_loss = tf.reduce_mean(tf.abs(shift1-shift2)) * 0.01
accel = derivative(speed)
accel = tf.squeeze(accel)
accel = tf.transpose(accel)
accs_loss_large = tf.reduce_mean(tf.nn.relu(tf.abs(accel) - 4))
accs_loss_small = tf.reduce_mean(tf.abs(accel)) * 0.01
speed_loss_small = tf.reduce_mean(tf.abs(speed[2])) * 0.01 + shift_loss
'''
speed = (poses[3:] - poses[:-3])
speed_loss_small += tf.reduce_mean(tf.abs(poses[2:-1] - poses[1:-2]-speed/3))*0.01
accs = speed[1:] - speed | train_step_gnss | identifier_name |
dashboard.go | ", err)
return nil, err
}
jsonBody, err := gabs.ParseJSON(bodyBuf)
if err != nil |
// 'set-cookie': ['t=UpnUzNztGWO7K8A%2BCYihZz056Bk%3D; Path=/; Expires=Sat, 16 Nov 2013 06:27:19 GMT',
// 'un=mgoff%40appcelerator.com; Path=/; Expires=Sat, 16 Nov 2013 06:27:19 GMT',
// 'sid=33f33a6b7f8fef7b0fc649654187d467; Path=/; Expires=Sat, 16 Nov 2013 06:27:19 GMT',
// 'dvid=2019bea3-9e7b-48e3-890f-00e3e22b39e2; Path=/; Expires=Sat, 17 Oct 2015 06:27:19 GMT',
// 'connect.sid=s%3Aj0kX71OMFpIQ11Vf1ruhqJLH.on4RLy9q9tpVqnUeoQJBWlDPiB6bS8rWWhq8sOCDGPc; Domain=360-dev.appcelerator.com; Path=/; Expires=Sat, 16 Nov 2013 06:27:19 GMT; HttpOnly'
// ]
// {
// "success": true,
// "result": {
// "success": true,
// "username": "mgoff@appcelerator.com",
// "email": "mgoff@appcelerator.com",
// "guid": "ae6150453b3599b2875b311c40785b40",
// "org_id": 14301,
// "connect.sid": "s:QGW1cqj5h9B3fL6jwJTtjkuT.iuwQ23WOgiK/E+QfkRNVWi7G5S9DA00Li6BQPLGkROM"
// }
cookie := resp.Header.Get("set-cookie")
if cookie == "" {
log.Error("No cookie found in response")
return nil, errors.New("authentication failed")
}
sid := strings.Split(strings.Split(cookie, ";")[0], "=")[1]
log.Debugf("sid: %s", sid)
// for _, cookie := range cookies.([]string) {
// log.Debugf("cookie: %s", cookie)
// }
success := jsonBody.Path("success").Data().(bool)
if !success {
log.Error("dashboard returns false for success field")
return nil, errors.New("authentication failed")
}
err = handleDashboardSession(username, sid, cookie)
if err != nil {
return nil, err
}
haveAccess, orgs, err := getAndVerifyOrgInfoFrom360(username, sid)
if err != nil {
return nil, err
}
if !haveAccess {
log.Errorf("user's organizations do not have access to this domain")
return nil, errors.New("No access to this domain")
}
user := bson.M{
"username": jsonBody.Path("result.username").Data().(string),
"email": jsonBody.Path("result.email").Data().(string),
"guid": jsonBody.Path("result.guid").Data().(string),
}
if jsonBody.Path("result.firstname").Data() != nil {
user["firstname"] = jsonBody.Path("result.firstname").Data().(string)
} else {
user["firstname"] = jsonBody.Path("result.username").Data().(string)
}
//user's organization info returned from dashboard. It's an array since a user can belong to
//multiple organizations.
user["orgs_360"] = orgs
user["orgs_360_updated_at"] = time.Now()
savedUser, err := saveUser(user)
if err != nil {
log.Errorf("Failed to save user. %v", err)
return nil, err
}
mUser := &models.User{
ID: savedUser["_id"].(bson.ObjectId).Hex(),
Username: jsonBody.Path("result.username").Data().(string),
Email: jsonBody.Path("result.email").Data().(string),
Orgs: orgs,
}
if jsonBody.Path("result.firstname").Data() != nil {
mUser.Firstname = jsonBody.Path("result.firstname").Data().(string)
} else {
mUser.Firstname = jsonBody.Path("result.username").Data().(string)
}
return mUser, nil
}
func handleDashboardSession(username, sid_360, cookie string) error {
old_db_session, err := findDashboardSession(username)
if err != nil && !strings.Contains(err.Error(), "not found") {
return err
}
if _, ok := old_db_session["sid_360"]; ok {
err = logoutFromDashboard(old_db_session["sid_360"].(string))
if err != nil {
return err
}
}
// save 360 session to DB
db_session := bson.M{
"username": username,
"sid_360": sid_360,
"cookie": cookie,
}
return saveDashboardSession(db_session)
}
func getAndVerifyOrgInfoFrom360(username, sid string) (haveAccess bool, orgs []models.Org, err error) {
// reqTimeout := 20000; //20s
//curl -i -b connect.sid=s%3AaJaL7IWQ_cDvmVBeQRY997hf.vVzLV2aFvrYiEKmfdTARTuHessesQ0Xm87JvFESaus http://dashboard.appcelerator.com/api/v1/user/organizations
/*
response for invalid session
HTTP/1.1 401 Unauthorized
X-Frame-Options: SAMEORIGIN
Cache-Control: no-cache, max-age=0, must-revalidate
Pragma: no-cache
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, POST, PUT, PATCH, DELETE
Access-Control-Allow-Headers: Content-Type, api_key
Content-Type: application/json; charset=utf-8
Content-Length: 59
Set-Cookie: connect.sid=s%3AIEpzWmzs4MQJGJMEcLmjlZm_.Cyi4LlO8gP%2B4sPHR0bdEGqjiqjuW3RJlZe6O2bt8QkI; Domain=dashboard.appcelerator.com; Path=/; Expires=Sat, 12 Apr 2014 13:04:07 GMT; HttpOnly; Secure
Date: Thu, 13 Mar 2014 13:04:07 GMT
Connection: close
{"success":false,"description":"Login Required","code":401}
*/
log.Debug("Get user organization information from " + host360 + orgInfoPath)
orgInfoUrl := "https://" + host360 + orgInfoPath
//https://webcache.googleusercontent.com/search?q=cache:OVK76hrG4T8J:https://medium.com/%40nate510/don-t-use-go-s-default-http-client-4804cb19f779+&cd=4&hl=en&ct=clnk&gl=jp
client := &http.Client{}
req, err := http.NewRequest("GET", orgInfoUrl, nil)
req.Header.Add("Cookie", "connect.sid="+sid)
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
resp, err := client.Do(req)
if err != nil {
log.Errorf("Failed to get organization info from dashboard. %v", err)
return
}
//log.Debugf("resp: %v", resp)
if resp.StatusCode == 401 {
log.Warning("getAndVerifyOrgInfoFrom360 - Failed to get organization information. Session is invalid")
err = errors.New("Failed to get organization information. Session is invalid.")
return
}
if resp.StatusCode != 200 {
log.Debugf("dashboard returns status %s", resp.Status)
err = errors.New("Failed to get organization info")
return
}
bodyBuf, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
log.Errorf("Failed to read response body. %v", err)
return
}
jsonBody, err := gabs.ParseJSON(bodyBuf)
if err != nil {
| {
log.Errorf("Failed to parse response body. %v", err)
return nil, err
} | conditional_block |
dashboard.go | := bson.M{
"username": username,
"sid_360": sid_360,
"cookie": cookie,
}
return saveDashboardSession(db_session)
}
func getAndVerifyOrgInfoFrom360(username, sid string) (haveAccess bool, orgs []models.Org, err error) {
// reqTimeout := 20000; //20s
//curl -i -b connect.sid=s%3AaJaL7IWQ_cDvmVBeQRY997hf.vVzLV2aFvrYiEKmfdTARTuHessesQ0Xm87JvFESaus http://dashboard.appcelerator.com/api/v1/user/organizations
/*
response for invalid session
HTTP/1.1 401 Unauthorized
X-Frame-Options: SAMEORIGIN
Cache-Control: no-cache, max-age=0, must-revalidate
Pragma: no-cache
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, POST, PUT, PATCH, DELETE
Access-Control-Allow-Headers: Content-Type, api_key
Content-Type: application/json; charset=utf-8
Content-Length: 59
Set-Cookie: connect.sid=s%3AIEpzWmzs4MQJGJMEcLmjlZm_.Cyi4LlO8gP%2B4sPHR0bdEGqjiqjuW3RJlZe6O2bt8QkI; Domain=dashboard.appcelerator.com; Path=/; Expires=Sat, 12 Apr 2014 13:04:07 GMT; HttpOnly; Secure
Date: Thu, 13 Mar 2014 13:04:07 GMT
Connection: close
{"success":false,"description":"Login Required","code":401}
*/
log.Debug("Get user organization information from " + host360 + orgInfoPath)
orgInfoUrl := "https://" + host360 + orgInfoPath
//https://webcache.googleusercontent.com/search?q=cache:OVK76hrG4T8J:https://medium.com/%40nate510/don-t-use-go-s-default-http-client-4804cb19f779+&cd=4&hl=en&ct=clnk&gl=jp
client := &http.Client{}
req, err := http.NewRequest("GET", orgInfoUrl, nil)
req.Header.Add("Cookie", "connect.sid="+sid)
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
resp, err := client.Do(req)
if err != nil {
log.Errorf("Failed to get organization info from dashboard. %v", err)
return
}
//log.Debugf("resp: %v", resp)
if resp.StatusCode == 401 {
log.Warning("getAndVerifyOrgInfoFrom360 - Failed to get organization information. Session is invalid")
err = errors.New("Failed to get organization information. Session is invalid.")
return
}
if resp.StatusCode != 200 {
log.Debugf("dashboard returns status %s", resp.Status)
err = errors.New("Failed to get organization info")
return
}
bodyBuf, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
log.Errorf("Failed to read response body. %v", err)
return
}
jsonBody, err := gabs.ParseJSON(bodyBuf)
if err != nil {
log.Errorf("Failed to parse response body. %v", err)
return
}
success := jsonBody.Path("success").Data().(bool)
if !success {
log.Error("dashboard returns false for success field")
err = errors.New("Failed to get organization info")
return
}
/*
{
"success": true,
"result": [{
"_id": "51c40b4497a98c6046000002",
"org_id": 14301,
"name": "Appcelerator, Inc",
"guid": "64310644-794b-c8d0-a8b8-0a373d20dabc",
"user_count": 97,
"current_users_role": "normal",
"is_node_acs_admin": false,
"trial_end_date": "",
"created": "2012-01-11 10:58:09.0",
"reseller": false,
"active": true,
"envs": [{
"_id": "production",
"name": "production",
"isProduction": true,
"acsBaseUrl": "https://preprod-api.cloud.appcelerator.com",
"acsAuthBaseUrl": "https://dolphin-secure-identity.cloud.appcelerator.com",
"nodeACSEndpoint": "https://admin.cloudapp-enterprise-preprod.appcelerator.com"
}, {
"_id": "development",
"name": "development",
"isProduction": false,
"acsBaseUrl": "https://preprod-api.cloud.appcelerator.com",
"acsAuthBaseUrl": "https://dolphin-secure-identity.cloud.appcelerator.com",
"nodeACSEndpoint": "https://admin.cloudapp-enterprise-preprod.appcelerator.com"
}],
"parent_org_guid": ""
}]
}
*/
organizations := jsonBody.Path("result").Data().([]interface{})
if !validateOrgs(organizations) {
log.Errorf("getAndVerifyOrgInfoFrom360 - Bad response from dashboard: invalid organization info. %v", organizations)
err = errors.New("Bad response from dashboard")
return
//TODO send mail
}
//check if the user's organizations have access to current deployment (identified by admin host)
orgs, haveAccess = checkOrgs(organizations)
return
}
func checkOrgs(orgArray []interface{}) (orgs []models.Org, haveAccess bool) {
log.Debugf("check if user's organizations have access to this domain")
re := regexp.MustCompile("^(http|https)://") //https://golang.org/pkg/regexp/#MustCompile
thisEnvHost := re.ReplaceAllString(thisEnvAdminURL, "")
orgs = []models.Org{} //organizations which can access this domain (deployment)
userOrgIds := []string{}
for _, orgData := range orgArray {
orgDoc := orgData.(map[string]interface{})
orgToSave := models.Org{
ID: strconv.FormatFloat(orgDoc["org_id"].(float64), 'f', -1, 64),
Name: orgDoc["name"].(string),
Admin: orgDoc["current_users_role"].(string) == "admin",
Node_acs_admin: orgDoc["is_node_acs_admin"].(bool),
}
userOrgIds = append(userOrgIds, orgToSave.ID)
//check if the org has access to this domain (deployment)
//if yes save it in "orgs"
if envsData, ok := orgDoc["envs"]; ok {
envs := envsData.([]interface{})
for _, envData := range envs {
env := envData.(map[string]interface{})
adminHost, hok := env["nodeACSEndpoint"].(string)
if hok {
re := regexp.MustCompile("^(http|https)://")
adminHost := re.ReplaceAllString(adminHost, "")
log.Debugf("org %s(%s) have access to %s", orgToSave.Name, orgToSave.ID, adminHost)
if adminHost == thisEnvHost {
orgs = append(orgs, orgToSave)
break
}
}
}
}
}
//workaround for testing - start
// userOrgIds.push('14301');
// orgs.push({id:'14301', name:'appcelerator Inc.', admin: true, node_acs_admin: true});
//workaround for testing - end
if len(orgs) < 1 {
log.Errorf("getAndVerifyOrgInfoFrom360 - User's organization(s) %v doesn't have access to current deployment (%s).", userOrgIds, thisEnvHost)
haveAccess = false
return
}
haveAccess = true
return
}
/**
* Validate the organization info got from 360 for a user is valid.
* @param orgArray
* @returns {boolean}
*/
func validateOrgs(orgArray []interface{}) bool {
if len(orgArray) == 0 {
return false
}
for _, orgData := range orgArray {
orgDoc := orgData.(map[string]interface{})
if _, ok := orgDoc["org_id"]; !ok {
return false
}
if _, ok := orgDoc["name"]; !ok {
return false
}
if _, ok := orgDoc["is_node_acs_admin"]; !ok {
return false
}
}
return true
}
/**
* Load user's 360 session information based on username.
*/
func | findDashboardSession | identifier_name | |
dashboard.go | Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, POST, PUT, PATCH, DELETE
Access-Control-Allow-Headers: Content-Type, api_key
Content-Type: application/json; charset=utf-8
Content-Length: 59
Set-Cookie: connect.sid=s%3AIEpzWmzs4MQJGJMEcLmjlZm_.Cyi4LlO8gP%2B4sPHR0bdEGqjiqjuW3RJlZe6O2bt8QkI; Domain=dashboard.appcelerator.com; Path=/; Expires=Sat, 12 Apr 2014 13:04:07 GMT; HttpOnly; Secure
Date: Thu, 13 Mar 2014 13:04:07 GMT
Connection: close
{"success":false,"description":"Login Required","code":401}
*/
log.Debug("Get user organization information from " + host360 + orgInfoPath)
orgInfoUrl := "https://" + host360 + orgInfoPath
//https://webcache.googleusercontent.com/search?q=cache:OVK76hrG4T8J:https://medium.com/%40nate510/don-t-use-go-s-default-http-client-4804cb19f779+&cd=4&hl=en&ct=clnk&gl=jp
client := &http.Client{}
req, err := http.NewRequest("GET", orgInfoUrl, nil)
req.Header.Add("Cookie", "connect.sid="+sid)
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
resp, err := client.Do(req)
if err != nil {
log.Errorf("Failed to get organization info from dashboard. %v", err)
return
}
//log.Debugf("resp: %v", resp)
if resp.StatusCode == 401 {
log.Warning("getAndVerifyOrgInfoFrom360 - Failed to get organization information. Session is invalid")
err = errors.New("Failed to get organization information. Session is invalid.")
return
}
if resp.StatusCode != 200 {
log.Debugf("dashboard returns status %s", resp.Status)
err = errors.New("Failed to get organization info")
return
}
bodyBuf, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
log.Errorf("Failed to read response body. %v", err)
return
}
jsonBody, err := gabs.ParseJSON(bodyBuf)
if err != nil {
log.Errorf("Failed to parse response body. %v", err)
return
}
success := jsonBody.Path("success").Data().(bool)
if !success {
log.Error("dashboard returns false for success field")
err = errors.New("Failed to get organization info")
return
}
/*
{
"success": true,
"result": [{
"_id": "51c40b4497a98c6046000002",
"org_id": 14301,
"name": "Appcelerator, Inc",
"guid": "64310644-794b-c8d0-a8b8-0a373d20dabc",
"user_count": 97,
"current_users_role": "normal",
"is_node_acs_admin": false,
"trial_end_date": "",
"created": "2012-01-11 10:58:09.0",
"reseller": false,
"active": true,
"envs": [{
"_id": "production",
"name": "production",
"isProduction": true,
"acsBaseUrl": "https://preprod-api.cloud.appcelerator.com",
"acsAuthBaseUrl": "https://dolphin-secure-identity.cloud.appcelerator.com",
"nodeACSEndpoint": "https://admin.cloudapp-enterprise-preprod.appcelerator.com"
}, {
"_id": "development",
"name": "development",
"isProduction": false,
"acsBaseUrl": "https://preprod-api.cloud.appcelerator.com",
"acsAuthBaseUrl": "https://dolphin-secure-identity.cloud.appcelerator.com",
"nodeACSEndpoint": "https://admin.cloudapp-enterprise-preprod.appcelerator.com"
}],
"parent_org_guid": ""
}]
}
*/
organizations := jsonBody.Path("result").Data().([]interface{})
if !validateOrgs(organizations) {
log.Errorf("getAndVerifyOrgInfoFrom360 - Bad response from dashboard: invalid organization info. %v", organizations)
err = errors.New("Bad response from dashboard")
return
//TODO send mail
}
//check if the user's organizations have access to current deployment (identified by admin host)
orgs, haveAccess = checkOrgs(organizations)
return
}
func checkOrgs(orgArray []interface{}) (orgs []models.Org, haveAccess bool) {
log.Debugf("check if user's organizations have access to this domain")
re := regexp.MustCompile("^(http|https)://") //https://golang.org/pkg/regexp/#MustCompile
thisEnvHost := re.ReplaceAllString(thisEnvAdminURL, "")
orgs = []models.Org{} //organizations which can access this domain (deployment)
userOrgIds := []string{}
for _, orgData := range orgArray {
orgDoc := orgData.(map[string]interface{})
orgToSave := models.Org{
ID: strconv.FormatFloat(orgDoc["org_id"].(float64), 'f', -1, 64),
Name: orgDoc["name"].(string),
Admin: orgDoc["current_users_role"].(string) == "admin",
Node_acs_admin: orgDoc["is_node_acs_admin"].(bool),
}
userOrgIds = append(userOrgIds, orgToSave.ID)
//check if the org has access to this domain (deployment)
//if yes save it in "orgs"
if envsData, ok := orgDoc["envs"]; ok {
envs := envsData.([]interface{})
for _, envData := range envs {
env := envData.(map[string]interface{})
adminHost, hok := env["nodeACSEndpoint"].(string)
if hok {
re := regexp.MustCompile("^(http|https)://")
adminHost := re.ReplaceAllString(adminHost, "")
log.Debugf("org %s(%s) have access to %s", orgToSave.Name, orgToSave.ID, adminHost)
if adminHost == thisEnvHost {
orgs = append(orgs, orgToSave)
break
}
}
}
}
}
//workaround for testing - start
// userOrgIds.push('14301');
// orgs.push({id:'14301', name:'appcelerator Inc.', admin: true, node_acs_admin: true});
//workaround for testing - end
if len(orgs) < 1 {
log.Errorf("getAndVerifyOrgInfoFrom360 - User's organization(s) %v doesn't have access to current deployment (%s).", userOrgIds, thisEnvHost)
haveAccess = false
return
}
haveAccess = true
return
}
/**
* Validate the organization info got from 360 for a user is valid.
* @param orgArray
* @returns {boolean}
*/
func validateOrgs(orgArray []interface{}) bool {
if len(orgArray) == 0 {
return false
}
for _, orgData := range orgArray {
orgDoc := orgData.(map[string]interface{})
if _, ok := orgDoc["org_id"]; !ok {
return false
}
if _, ok := orgDoc["name"]; !ok {
return false
}
if _, ok := orgDoc["is_node_acs_admin"]; !ok {
return false
}
}
return true
}
/**
* Load user's 360 session information based on username.
*/
func findDashboardSession(username string) (bson.M, error) {
log.Debugf("find dashboard session for user %s", username)
re, err := mongo.FindOneDocument(mongo.STRATUS_DASHBOARD_SESSIONS_COLL,
bson.M{"username": username})
if err != nil {
log.Errorf("Failed to find dashboard session. %v", err)
return nil, err
}
return re, err
}
/**
* insert or update user's 360 session information upon login to 360
*/
func saveDashboardSession(session bson.M) error | {
log.Debugf("save dashboard session for user %v", session["username"])
_, err := mongo.UpsertDocument(mongo.STRATUS_DASHBOARD_SESSIONS_COLL,
bson.M{"username": session["username"]}, session)
if err != nil {
log.Errorf("Failed to save dashboard session. %v", err)
return err
}
log.Debugf("Upserted %v into %s collection.", session, mongo.STRATUS_DASHBOARD_SESSIONS_COLL)
return nil
} | identifier_body | |
dashboard.go | , err error) {
// reqTimeout := 20000; //20s
//curl -i -b connect.sid=s%3AaJaL7IWQ_cDvmVBeQRY997hf.vVzLV2aFvrYiEKmfdTARTuHessesQ0Xm87JvFESaus http://dashboard.appcelerator.com/api/v1/user/organizations
/*
response for invalid session
HTTP/1.1 401 Unauthorized
X-Frame-Options: SAMEORIGIN
Cache-Control: no-cache, max-age=0, must-revalidate
Pragma: no-cache
Vary: Accept-Encoding
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, POST, PUT, PATCH, DELETE
Access-Control-Allow-Headers: Content-Type, api_key
Content-Type: application/json; charset=utf-8
Content-Length: 59
Set-Cookie: connect.sid=s%3AIEpzWmzs4MQJGJMEcLmjlZm_.Cyi4LlO8gP%2B4sPHR0bdEGqjiqjuW3RJlZe6O2bt8QkI; Domain=dashboard.appcelerator.com; Path=/; Expires=Sat, 12 Apr 2014 13:04:07 GMT; HttpOnly; Secure
Date: Thu, 13 Mar 2014 13:04:07 GMT
Connection: close
{"success":false,"description":"Login Required","code":401}
*/
log.Debug("Get user organization information from " + host360 + orgInfoPath)
orgInfoUrl := "https://" + host360 + orgInfoPath
//https://webcache.googleusercontent.com/search?q=cache:OVK76hrG4T8J:https://medium.com/%40nate510/don-t-use-go-s-default-http-client-4804cb19f779+&cd=4&hl=en&ct=clnk&gl=jp
client := &http.Client{}
req, err := http.NewRequest("GET", orgInfoUrl, nil)
req.Header.Add("Cookie", "connect.sid="+sid)
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
resp, err := client.Do(req)
if err != nil {
log.Errorf("Failed to get organization info from dashboard. %v", err)
return
}
//log.Debugf("resp: %v", resp)
if resp.StatusCode == 401 {
log.Warning("getAndVerifyOrgInfoFrom360 - Failed to get organization information. Session is invalid")
err = errors.New("Failed to get organization information. Session is invalid.")
return
}
if resp.StatusCode != 200 {
log.Debugf("dashboard returns status %s", resp.Status)
err = errors.New("Failed to get organization info")
return
}
bodyBuf, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
log.Errorf("Failed to read response body. %v", err)
return
}
jsonBody, err := gabs.ParseJSON(bodyBuf)
if err != nil {
log.Errorf("Failed to parse response body. %v", err)
return
}
success := jsonBody.Path("success").Data().(bool)
if !success {
log.Error("dashboard returns false for success field")
err = errors.New("Failed to get organization info")
return
}
/*
{
"success": true,
"result": [{
"_id": "51c40b4497a98c6046000002",
"org_id": 14301,
"name": "Appcelerator, Inc",
"guid": "64310644-794b-c8d0-a8b8-0a373d20dabc",
"user_count": 97,
"current_users_role": "normal",
"is_node_acs_admin": false,
"trial_end_date": "",
"created": "2012-01-11 10:58:09.0",
"reseller": false,
"active": true,
"envs": [{
"_id": "production",
"name": "production",
"isProduction": true,
"acsBaseUrl": "https://preprod-api.cloud.appcelerator.com",
"acsAuthBaseUrl": "https://dolphin-secure-identity.cloud.appcelerator.com",
"nodeACSEndpoint": "https://admin.cloudapp-enterprise-preprod.appcelerator.com"
}, {
"_id": "development",
"name": "development",
"isProduction": false,
"acsBaseUrl": "https://preprod-api.cloud.appcelerator.com",
"acsAuthBaseUrl": "https://dolphin-secure-identity.cloud.appcelerator.com",
"nodeACSEndpoint": "https://admin.cloudapp-enterprise-preprod.appcelerator.com"
}],
"parent_org_guid": ""
}]
}
*/
organizations := jsonBody.Path("result").Data().([]interface{})
if !validateOrgs(organizations) {
log.Errorf("getAndVerifyOrgInfoFrom360 - Bad response from dashboard: invalid organization info. %v", organizations)
err = errors.New("Bad response from dashboard")
return
//TODO send mail
}
//check if the user's organizations have access to current deployment (identified by admin host)
orgs, haveAccess = checkOrgs(organizations)
return
}
func checkOrgs(orgArray []interface{}) (orgs []models.Org, haveAccess bool) {
log.Debugf("check if user's organizations have access to this domain")
re := regexp.MustCompile("^(http|https)://") //https://golang.org/pkg/regexp/#MustCompile
thisEnvHost := re.ReplaceAllString(thisEnvAdminURL, "")
orgs = []models.Org{} //organizations which can access this domain (deployment)
userOrgIds := []string{}
for _, orgData := range orgArray {
orgDoc := orgData.(map[string]interface{})
orgToSave := models.Org{
ID: strconv.FormatFloat(orgDoc["org_id"].(float64), 'f', -1, 64),
Name: orgDoc["name"].(string),
Admin: orgDoc["current_users_role"].(string) == "admin",
Node_acs_admin: orgDoc["is_node_acs_admin"].(bool),
}
userOrgIds = append(userOrgIds, orgToSave.ID)
//check if the org has access to this domain (deployment)
//if yes save it in "orgs"
if envsData, ok := orgDoc["envs"]; ok {
envs := envsData.([]interface{})
for _, envData := range envs {
env := envData.(map[string]interface{})
adminHost, hok := env["nodeACSEndpoint"].(string)
if hok {
re := regexp.MustCompile("^(http|https)://")
adminHost := re.ReplaceAllString(adminHost, "")
log.Debugf("org %s(%s) have access to %s", orgToSave.Name, orgToSave.ID, adminHost)
if adminHost == thisEnvHost {
orgs = append(orgs, orgToSave)
break
}
}
}
}
}
//workaround for testing - start
// userOrgIds.push('14301');
// orgs.push({id:'14301', name:'appcelerator Inc.', admin: true, node_acs_admin: true});
//workaround for testing - end
if len(orgs) < 1 {
log.Errorf("getAndVerifyOrgInfoFrom360 - User's organization(s) %v doesn't have access to current deployment (%s).", userOrgIds, thisEnvHost)
haveAccess = false
return
}
haveAccess = true
return
}
/**
* Validate the organization info got from 360 for a user is valid.
* @param orgArray
* @returns {boolean}
*/
func validateOrgs(orgArray []interface{}) bool {
if len(orgArray) == 0 {
return false
}
for _, orgData := range orgArray {
orgDoc := orgData.(map[string]interface{})
if _, ok := orgDoc["org_id"]; !ok {
return false
}
if _, ok := orgDoc["name"]; !ok {
return false
}
if _, ok := orgDoc["is_node_acs_admin"]; !ok {
return false
}
}
return true
}
/**
* Load user's 360 session information based on username.
*/
func findDashboardSession(username string) (bson.M, error) {
log.Debugf("find dashboard session for user %s", username)
re, err := mongo.FindOneDocument(mongo.STRATUS_DASHBOARD_SESSIONS_COLL,
bson.M{"username": username}) |
if err != nil {
log.Errorf("Failed to find dashboard session. %v", err) | random_line_split | |
lib.rs | ();
//!
//! // start some readers
//! let readers: Vec<_> = (0..4).map(|_| {
//! let r = book_reviews_r.clone();
//! thread::spawn(move || {
//! loop {
//! let l = r.len();
//! if l == 0 {
//! thread::yield_now();
//! } else {
//! // the reader will either see all the reviews,
//! // or none of them, since refresh() is atomic.
//! assert_eq!(l, 4);
//! break;
//! }
//! }
//! })
//! }).collect();
//!
//! // do some writes
//! book_reviews_w.insert("Adventures of Huckleberry Finn", "My favorite book.");
//! book_reviews_w.insert("Grimms' Fairy Tales", "Masterpiece.");
//! book_reviews_w.insert("Pride and Prejudice", "Very enjoyable.");
//! book_reviews_w.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot.");
//! // expose the writes
//! book_reviews_w.publish();
//!
//! // you can read through the write handle
//! assert_eq!(book_reviews_w.len(), 4);
//!
//! // the original read handle still works too
//! assert_eq!(book_reviews_r.len(), 4);
//!
//! // all the threads should eventually see .len() == 4
//! for r in readers.into_iter() {
//! assert!(r.join().is_ok());
//! }
//! ```
//!
//! If multiple writers are needed, the `WriteHandle` must be protected by a `Mutex`.
//!
//! ```
//! use std::thread;
//! use std::sync::{Arc, Mutex};
//! let (mut book_reviews_w, book_reviews_r) = evmap::new();
//!
//! // start some writers.
//! // since evmap does not support concurrent writes, we need
//! // to protect the write handle by a mutex.
//! let w = Arc::new(Mutex::new(book_reviews_w));
//! let writers: Vec<_> = (0..4).map(|i| {
//! let w = w.clone();
//! thread::spawn(move || {
//! let mut w = w.lock().unwrap();
//! w.insert(i, true);
//! w.publish();
//! })
//! }).collect();
//!
//! // eventually we should see all the writes
//! while book_reviews_r.len() < 4 { thread::yield_now(); };
//!
//! // all the threads should eventually finish writing
//! for w in writers.into_iter() {
//! assert!(w.join().is_ok());
//! }
//! ```
//!
//! [`ReadHandle`] is not `Sync` as sharing a single instance amongst threads would introduce a
//! significant performance bottleneck. A fresh `ReadHandle` needs to be created for each thread
//! either by cloning a [`ReadHandle`] or from a [`handles::ReadHandleFactory`]. For further
//! information, see [`left_right::ReadHandle`].
//!
//! # Implementation
//!
//! Under the hood, the map is implemented using two regular `HashMap`s and some magic. Take a look
//! at [`left-right`](left_right) for a much more in-depth discussion. Since the implementation
//! uses regular `HashMap`s under the hood, table resizing is fully supported. It does, however,
//! also mean that the memory usage of this implementation is approximately twice of that of a
//! regular `HashMap`, and more if writers rarely refresh after writing.
//!
//! # Value storage
//!
//! The values for each key in the map are stored in [`refs::Values`]. Conceptually, each `Values`
//! is a _bag_ or _multiset_; it can store multiple copies of the same value. `evmap` applies some
//! cleverness in an attempt to reduce unnecessary allocations and keep the cost of operations on
//! even large value-bags small. For small bags, `Values` uses the `smallvec` crate. This avoids
//! allocation entirely for single-element bags, and uses a `Vec` if the bag is relatively small.
//! For large bags, `Values` uses the `hashbag` crate, which enables `evmap` to efficiently look up
//! and remove specific elements in the value bag. For bags larger than one element, but smaller
//! than the threshold for moving to `hashbag`, we use `smallvec` to avoid unnecessary hashing.
//! Operations such as `Fit` and `Replace` will automatically switch back to the inline storage if
//! possible. This is ideal for maps that mostly use one element per key, as it can improvate
//! memory locality with less indirection.
#![warn(
missing_docs,
rust_2018_idioms,
missing_debug_implementations,
broken_intra_doc_links
)]
#![allow(clippy::type_complexity)]
// This _should_ detect if we ever accidentally leak aliasing::NoDrop.
// But, currently, it does not..
#![deny(unreachable_pub)]
#![cfg_attr(docsrs, feature(doc_cfg))]
use crate::inner::Inner;
use crate::read::ReadHandle;
use crate::write::WriteHandle;
use left_right::aliasing::Aliased;
use std::collections::hash_map::RandomState;
use std::fmt;
use std::hash::{BuildHasher, Hash};
mod inner;
mod read;
mod stable_hash_eq;
mod values;
mod write;
pub use stable_hash_eq::StableHashEq;
/// Handles to the read and write halves of an `evmap`.
pub mod handles {
pub use crate::write::WriteHandle;
// These cannot use ::{..} syntax because of
// https://github.com/rust-lang/rust/issues/57411
pub use crate::read::ReadHandle;
pub use crate::read::ReadHandleFactory;
}
/// Helper types that give access to values inside the read half of an `evmap`.
pub mod refs {
// Same here, ::{..} won't work.
pub use super::values::Values;
pub use crate::read::MapReadRef;
pub use crate::read::ReadGuardIter;
// Expose `ReadGuard` since it has useful methods the user will likely care about.
#[doc(inline)]
pub use left_right::ReadGuard;
}
// NOTE: It is _critical_ that this module is not public.
mod aliasing;
/// Options for how to initialize the map.
///
/// In particular, the options dictate the hashing function, meta type, and initial capacity of the
/// map.
pub struct Options<M, S>
where
S: BuildHasher,
{
meta: M,
hasher: S,
capacity: Option<usize>,
}
impl<M, S> fmt::Debug for Options<M, S>
where
S: BuildHasher,
M: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Options")
.field("meta", &self.meta)
.field("capacity", &self.capacity)
.finish()
}
}
impl Default for Options<(), RandomState> {
fn default() -> Self {
Options {
meta: (),
hasher: RandomState::default(),
capacity: None,
}
}
}
impl<M, S> Options<M, S>
where
S: BuildHasher,
{
/// Set the initial meta value for the map.
pub fn with_meta<M2>(self, meta: M2) -> Options<M2, S> {
Options {
meta,
hasher: self.hasher,
capacity: self.capacity,
}
}
/// Set the hasher used for the map.
///
/// # Safety
///
/// This method is safe to call as long as the given hasher is deterministic. That is, it must
/// yield the same hash if given the same sequence of inputs.
pub unsafe fn with_hasher<S2>(self, hash_builder: S2) -> Options<M, S2>
where
S2: BuildHasher + Clone,
{
Options {
meta: self.meta,
hasher: hash_builder,
capacity: self.capacity,
}
}
/// Set the initial capacity for the map.
pub fn with_capacity(self, capacity: usize) -> Options<M, S> {
Options {
meta: self.meta,
hasher: self.hasher,
capacity: Some(capacity),
}
}
/// Create the map, and construct the read and write handles used to access it.
///
/// If you want to use arbitrary types for the keys and values, use [`assert_stable`][Options::assert_stable].
#[allow(clippy::type_complexity)]
pub fn construct<K, V>(self) -> (WriteHandle<K, V, M, S>, ReadHandle<K, V, M, S>)
where
K: StableHashEq + Clone,
S: BuildHasher + Clone,
V: StableHashEq,
M: 'static + Clone,
{
unsafe { self.assert_stable() }
}
/// Create the map, and construct the read and write handles used to access it.
///
/// # Safety
///
/// This method is safe to call as long as the implementation of `Hash` and `Eq` for both `K`
/// and `V` are deterministic. That is, they must always yield the same result if given the
/// same inputs. For keys of type `K`, the result must also be consistent between different clones
/// of the same key.
#[allow(clippy::type_complexity)]
pub unsafe fn | assert_stable | identifier_name | |
lib.rs | is atomic.
//! assert_eq!(l, 4);
//! break;
//! }
//! }
//! })
//! }).collect();
//!
//! // do some writes
//! book_reviews_w.insert("Adventures of Huckleberry Finn", "My favorite book.");
//! book_reviews_w.insert("Grimms' Fairy Tales", "Masterpiece.");
//! book_reviews_w.insert("Pride and Prejudice", "Very enjoyable.");
//! book_reviews_w.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot.");
//! // expose the writes
//! book_reviews_w.publish();
//!
//! // you can read through the write handle
//! assert_eq!(book_reviews_w.len(), 4);
//!
//! // the original read handle still works too
//! assert_eq!(book_reviews_r.len(), 4);
//!
//! // all the threads should eventually see .len() == 4
//! for r in readers.into_iter() {
//! assert!(r.join().is_ok());
//! }
//! ```
//!
//! If multiple writers are needed, the `WriteHandle` must be protected by a `Mutex`.
//!
//! ```
//! use std::thread;
//! use std::sync::{Arc, Mutex};
//! let (mut book_reviews_w, book_reviews_r) = evmap::new();
//!
//! // start some writers.
//! // since evmap does not support concurrent writes, we need
//! // to protect the write handle by a mutex.
//! let w = Arc::new(Mutex::new(book_reviews_w));
//! let writers: Vec<_> = (0..4).map(|i| {
//! let w = w.clone();
//! thread::spawn(move || {
//! let mut w = w.lock().unwrap();
//! w.insert(i, true);
//! w.publish();
//! })
//! }).collect();
//!
//! // eventually we should see all the writes
//! while book_reviews_r.len() < 4 { thread::yield_now(); };
//!
//! // all the threads should eventually finish writing
//! for w in writers.into_iter() {
//! assert!(w.join().is_ok());
//! }
//! ```
//!
//! [`ReadHandle`] is not `Sync` as sharing a single instance amongst threads would introduce a
//! significant performance bottleneck. A fresh `ReadHandle` needs to be created for each thread
//! either by cloning a [`ReadHandle`] or from a [`handles::ReadHandleFactory`]. For further
//! information, see [`left_right::ReadHandle`].
//!
//! # Implementation
//!
//! Under the hood, the map is implemented using two regular `HashMap`s and some magic. Take a look
//! at [`left-right`](left_right) for a much more in-depth discussion. Since the implementation
//! uses regular `HashMap`s under the hood, table resizing is fully supported. It does, however,
//! also mean that the memory usage of this implementation is approximately twice of that of a
//! regular `HashMap`, and more if writers rarely refresh after writing.
//!
//! # Value storage
//!
//! The values for each key in the map are stored in [`refs::Values`]. Conceptually, each `Values`
//! is a _bag_ or _multiset_; it can store multiple copies of the same value. `evmap` applies some
//! cleverness in an attempt to reduce unnecessary allocations and keep the cost of operations on
//! even large value-bags small. For small bags, `Values` uses the `smallvec` crate. This avoids
//! allocation entirely for single-element bags, and uses a `Vec` if the bag is relatively small.
//! For large bags, `Values` uses the `hashbag` crate, which enables `evmap` to efficiently look up
//! and remove specific elements in the value bag. For bags larger than one element, but smaller
//! than the threshold for moving to `hashbag`, we use `smallvec` to avoid unnecessary hashing.
//! Operations such as `Fit` and `Replace` will automatically switch back to the inline storage if
//! possible. This is ideal for maps that mostly use one element per key, as it can improvate
//! memory locality with less indirection.
#![warn(
missing_docs,
rust_2018_idioms,
missing_debug_implementations,
broken_intra_doc_links
)]
#![allow(clippy::type_complexity)]
// This _should_ detect if we ever accidentally leak aliasing::NoDrop.
// But, currently, it does not..
#![deny(unreachable_pub)]
#![cfg_attr(docsrs, feature(doc_cfg))]
use crate::inner::Inner;
use crate::read::ReadHandle;
use crate::write::WriteHandle;
use left_right::aliasing::Aliased;
use std::collections::hash_map::RandomState;
use std::fmt;
use std::hash::{BuildHasher, Hash};
mod inner;
mod read;
mod stable_hash_eq;
mod values;
mod write;
pub use stable_hash_eq::StableHashEq;
/// Handles to the read and write halves of an `evmap`.
pub mod handles {
pub use crate::write::WriteHandle;
// These cannot use ::{..} syntax because of
// https://github.com/rust-lang/rust/issues/57411
pub use crate::read::ReadHandle;
pub use crate::read::ReadHandleFactory;
}
/// Helper types that give access to values inside the read half of an `evmap`.
pub mod refs {
// Same here, ::{..} won't work.
pub use super::values::Values;
pub use crate::read::MapReadRef;
pub use crate::read::ReadGuardIter;
// Expose `ReadGuard` since it has useful methods the user will likely care about.
#[doc(inline)]
pub use left_right::ReadGuard;
}
// NOTE: It is _critical_ that this module is not public.
mod aliasing;
/// Options for how to initialize the map.
///
/// In particular, the options dictate the hashing function, meta type, and initial capacity of the
/// map.
pub struct Options<M, S>
where
S: BuildHasher,
{
meta: M,
hasher: S,
capacity: Option<usize>,
}
impl<M, S> fmt::Debug for Options<M, S>
where
S: BuildHasher,
M: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Options")
.field("meta", &self.meta)
.field("capacity", &self.capacity)
.finish()
}
}
impl Default for Options<(), RandomState> {
fn default() -> Self {
Options {
meta: (),
hasher: RandomState::default(),
capacity: None,
}
}
}
impl<M, S> Options<M, S>
where
S: BuildHasher,
{
/// Set the initial meta value for the map.
pub fn with_meta<M2>(self, meta: M2) -> Options<M2, S> {
Options {
meta,
hasher: self.hasher,
capacity: self.capacity,
}
}
/// Set the hasher used for the map.
///
/// # Safety
///
/// This method is safe to call as long as the given hasher is deterministic. That is, it must
/// yield the same hash if given the same sequence of inputs.
pub unsafe fn with_hasher<S2>(self, hash_builder: S2) -> Options<M, S2>
where
S2: BuildHasher + Clone,
{
Options {
meta: self.meta,
hasher: hash_builder,
capacity: self.capacity,
}
}
/// Set the initial capacity for the map.
pub fn with_capacity(self, capacity: usize) -> Options<M, S> {
Options {
meta: self.meta,
hasher: self.hasher,
capacity: Some(capacity),
}
}
/// Create the map, and construct the read and write handles used to access it.
///
/// If you want to use arbitrary types for the keys and values, use [`assert_stable`][Options::assert_stable].
#[allow(clippy::type_complexity)]
pub fn construct<K, V>(self) -> (WriteHandle<K, V, M, S>, ReadHandle<K, V, M, S>)
where
K: StableHashEq + Clone,
S: BuildHasher + Clone,
V: StableHashEq,
M: 'static + Clone,
{
unsafe { self.assert_stable() }
}
/// Create the map, and construct the read and write handles used to access it.
///
/// # Safety
///
/// This method is safe to call as long as the implementation of `Hash` and `Eq` for both `K`
/// and `V` are deterministic. That is, they must always yield the same result if given the
/// same inputs. For keys of type `K`, the result must also be consistent between different clones
/// of the same key.
#[allow(clippy::type_complexity)]
pub unsafe fn assert_stable<K, V>(self) -> (WriteHandle<K, V, M, S>, ReadHandle<K, V, M, S>)
where
K: Eq + Hash + Clone,
S: BuildHasher + Clone,
V: Eq + Hash,
M: 'static + Clone,
{
let inner = if let Some(cap) = self.capacity | {
Inner::with_capacity_and_hasher(self.meta, cap, self.hasher)
} | conditional_block | |
lib.rs | `.
//!
//! ```
//! use std::thread;
//! let (mut book_reviews_w, book_reviews_r) = evmap::new();
//!
//! // start some readers
//! let readers: Vec<_> = (0..4).map(|_| {
//! let r = book_reviews_r.clone();
//! thread::spawn(move || {
//! loop {
//! let l = r.len();
//! if l == 0 {
//! thread::yield_now();
//! } else {
//! // the reader will either see all the reviews,
//! // or none of them, since refresh() is atomic.
//! assert_eq!(l, 4);
//! break;
//! }
//! }
//! })
//! }).collect();
//!
//! // do some writes
//! book_reviews_w.insert("Adventures of Huckleberry Finn", "My favorite book.");
//! book_reviews_w.insert("Grimms' Fairy Tales", "Masterpiece.");
//! book_reviews_w.insert("Pride and Prejudice", "Very enjoyable.");
//! book_reviews_w.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot.");
//! // expose the writes
//! book_reviews_w.publish();
//!
//! // you can read through the write handle
//! assert_eq!(book_reviews_w.len(), 4);
//!
//! // the original read handle still works too
//! assert_eq!(book_reviews_r.len(), 4);
//!
//! // all the threads should eventually see .len() == 4
//! for r in readers.into_iter() {
//! assert!(r.join().is_ok());
//! }
//! ```
//!
//! If multiple writers are needed, the `WriteHandle` must be protected by a `Mutex`.
//!
//! ```
//! use std::thread;
//! use std::sync::{Arc, Mutex};
//! let (mut book_reviews_w, book_reviews_r) = evmap::new();
//!
//! // start some writers.
//! // since evmap does not support concurrent writes, we need
//! // to protect the write handle by a mutex.
//! let w = Arc::new(Mutex::new(book_reviews_w));
//! let writers: Vec<_> = (0..4).map(|i| {
//! let w = w.clone();
//! thread::spawn(move || {
//! let mut w = w.lock().unwrap();
//! w.insert(i, true);
//! w.publish();
//! })
//! }).collect();
//!
//! // eventually we should see all the writes
//! while book_reviews_r.len() < 4 { thread::yield_now(); };
//!
//! // all the threads should eventually finish writing
//! for w in writers.into_iter() {
//! assert!(w.join().is_ok());
//! }
//! ```
//!
//! [`ReadHandle`] is not `Sync` as sharing a single instance amongst threads would introduce a
//! significant performance bottleneck. A fresh `ReadHandle` needs to be created for each thread
//! either by cloning a [`ReadHandle`] or from a [`handles::ReadHandleFactory`]. For further
//! information, see [`left_right::ReadHandle`].
//!
//! # Implementation
//!
//! Under the hood, the map is implemented using two regular `HashMap`s and some magic. Take a look
//! at [`left-right`](left_right) for a much more in-depth discussion. Since the implementation
//! uses regular `HashMap`s under the hood, table resizing is fully supported. It does, however,
//! also mean that the memory usage of this implementation is approximately twice of that of a
//! regular `HashMap`, and more if writers rarely refresh after writing.
//!
//! # Value storage
//!
//! The values for each key in the map are stored in [`refs::Values`]. Conceptually, each `Values`
//! is a _bag_ or _multiset_; it can store multiple copies of the same value. `evmap` applies some
//! cleverness in an attempt to reduce unnecessary allocations and keep the cost of operations on
//! even large value-bags small. For small bags, `Values` uses the `smallvec` crate. This avoids
//! allocation entirely for single-element bags, and uses a `Vec` if the bag is relatively small.
//! For large bags, `Values` uses the `hashbag` crate, which enables `evmap` to efficiently look up
//! and remove specific elements in the value bag. For bags larger than one element, but smaller
//! than the threshold for moving to `hashbag`, we use `smallvec` to avoid unnecessary hashing.
//! Operations such as `Fit` and `Replace` will automatically switch back to the inline storage if
//! possible. This is ideal for maps that mostly use one element per key, as it can improvate
//! memory locality with less indirection.
#![warn(
missing_docs,
rust_2018_idioms,
missing_debug_implementations,
broken_intra_doc_links
)]
#![allow(clippy::type_complexity)]
// This _should_ detect if we ever accidentally leak aliasing::NoDrop.
// But, currently, it does not..
#![deny(unreachable_pub)]
#![cfg_attr(docsrs, feature(doc_cfg))]
use crate::inner::Inner;
use crate::read::ReadHandle;
use crate::write::WriteHandle;
use left_right::aliasing::Aliased;
use std::collections::hash_map::RandomState;
use std::fmt;
use std::hash::{BuildHasher, Hash};
mod inner;
mod read;
mod stable_hash_eq;
mod values;
mod write;
pub use stable_hash_eq::StableHashEq;
/// Handles to the read and write halves of an `evmap`.
pub mod handles {
pub use crate::write::WriteHandle;
// These cannot use ::{..} syntax because of
// https://github.com/rust-lang/rust/issues/57411
pub use crate::read::ReadHandle;
pub use crate::read::ReadHandleFactory;
}
/// Helper types that give access to values inside the read half of an `evmap`.
pub mod refs {
// Same here, ::{..} won't work.
pub use super::values::Values;
pub use crate::read::MapReadRef;
pub use crate::read::ReadGuardIter;
// Expose `ReadGuard` since it has useful methods the user will likely care about.
#[doc(inline)]
pub use left_right::ReadGuard;
}
// NOTE: It is _critical_ that this module is not public.
mod aliasing;
/// Options for how to initialize the map.
///
/// In particular, the options dictate the hashing function, meta type, and initial capacity of the
/// map.
pub struct Options<M, S>
where
S: BuildHasher,
{
meta: M,
hasher: S,
capacity: Option<usize>,
}
impl<M, S> fmt::Debug for Options<M, S>
where
S: BuildHasher,
M: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Options")
.field("meta", &self.meta)
.field("capacity", &self.capacity)
.finish()
}
}
impl Default for Options<(), RandomState> {
fn default() -> Self {
Options {
meta: (),
hasher: RandomState::default(),
capacity: None,
}
}
}
impl<M, S> Options<M, S>
where
S: BuildHasher,
{
/// Set the initial meta value for the map.
pub fn with_meta<M2>(self, meta: M2) -> Options<M2, S> {
Options {
meta,
hasher: self.hasher,
capacity: self.capacity,
}
}
/// Set the hasher used for the map.
///
/// # Safety
///
/// This method is safe to call as long as the given hasher is deterministic. That is, it must
/// yield the same hash if given the same sequence of inputs.
pub unsafe fn with_hasher<S2>(self, hash_builder: S2) -> Options<M, S2>
where
S2: BuildHasher + Clone,
{
Options {
meta: self.meta,
hasher: hash_builder,
capacity: self.capacity,
}
}
/// Set the initial capacity for the map.
pub fn with_capacity(self, capacity: usize) -> Options<M, S> {
Options {
meta: self.meta,
hasher: self.hasher,
capacity: Some(capacity),
}
}
/// Create the map, and construct the read and write handles used to access it.
///
/// If you want to use arbitrary types for the keys and values, use [`assert_stable`][Options::assert_stable].
#[allow(clippy::type_complexity)]
pub fn construct<K, V>(self) -> (WriteHandle<K, V, M, S>, ReadHandle<K, V, M, S>)
where
K: StableHashEq + Clone,
S: BuildHasher + Clone,
V: StableHashEq,
M: 'static + Clone,
{
unsafe { self.assert_stable() }
}
/// Create the map, and construct the read and write handles used to access it.
///
/// # Safety
///
/// This method is safe to call as long as the implementation of `Hash` and `Eq` for both `K`
/// and `V` are deterministic. That is, they must always yield the same result if given the | /// same inputs. For keys of type `K`, the result must also be consistent between different clones | random_line_split | |
lib.rs | book_reviews_w.insert("Grimms' Fairy Tales", "Masterpiece.");
//! book_reviews_w.insert("Pride and Prejudice", "Very enjoyable.");
//! book_reviews_w.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot.");
//! // expose the writes
//! book_reviews_w.publish();
//!
//! // you can read through the write handle
//! assert_eq!(book_reviews_w.len(), 4);
//!
//! // the original read handle still works too
//! assert_eq!(book_reviews_r.len(), 4);
//!
//! // all the threads should eventually see .len() == 4
//! for r in readers.into_iter() {
//! assert!(r.join().is_ok());
//! }
//! ```
//!
//! If multiple writers are needed, the `WriteHandle` must be protected by a `Mutex`.
//!
//! ```
//! use std::thread;
//! use std::sync::{Arc, Mutex};
//! let (mut book_reviews_w, book_reviews_r) = evmap::new();
//!
//! // start some writers.
//! // since evmap does not support concurrent writes, we need
//! // to protect the write handle by a mutex.
//! let w = Arc::new(Mutex::new(book_reviews_w));
//! let writers: Vec<_> = (0..4).map(|i| {
//! let w = w.clone();
//! thread::spawn(move || {
//! let mut w = w.lock().unwrap();
//! w.insert(i, true);
//! w.publish();
//! })
//! }).collect();
//!
//! // eventually we should see all the writes
//! while book_reviews_r.len() < 4 { thread::yield_now(); };
//!
//! // all the threads should eventually finish writing
//! for w in writers.into_iter() {
//! assert!(w.join().is_ok());
//! }
//! ```
//!
//! [`ReadHandle`] is not `Sync` as sharing a single instance amongst threads would introduce a
//! significant performance bottleneck. A fresh `ReadHandle` needs to be created for each thread
//! either by cloning a [`ReadHandle`] or from a [`handles::ReadHandleFactory`]. For further
//! information, see [`left_right::ReadHandle`].
//!
//! # Implementation
//!
//! Under the hood, the map is implemented using two regular `HashMap`s and some magic. Take a look
//! at [`left-right`](left_right) for a much more in-depth discussion. Since the implementation
//! uses regular `HashMap`s under the hood, table resizing is fully supported. It does, however,
//! also mean that the memory usage of this implementation is approximately twice of that of a
//! regular `HashMap`, and more if writers rarely refresh after writing.
//!
//! # Value storage
//!
//! The values for each key in the map are stored in [`refs::Values`]. Conceptually, each `Values`
//! is a _bag_ or _multiset_; it can store multiple copies of the same value. `evmap` applies some
//! cleverness in an attempt to reduce unnecessary allocations and keep the cost of operations on
//! even large value-bags small. For small bags, `Values` uses the `smallvec` crate. This avoids
//! allocation entirely for single-element bags, and uses a `Vec` if the bag is relatively small.
//! For large bags, `Values` uses the `hashbag` crate, which enables `evmap` to efficiently look up
//! and remove specific elements in the value bag. For bags larger than one element, but smaller
//! than the threshold for moving to `hashbag`, we use `smallvec` to avoid unnecessary hashing.
//! Operations such as `Fit` and `Replace` will automatically switch back to the inline storage if
//! possible. This is ideal for maps that mostly use one element per key, as it can improvate
//! memory locality with less indirection.
#![warn(
missing_docs,
rust_2018_idioms,
missing_debug_implementations,
broken_intra_doc_links
)]
#![allow(clippy::type_complexity)]
// This _should_ detect if we ever accidentally leak aliasing::NoDrop.
// But, currently, it does not..
#![deny(unreachable_pub)]
#![cfg_attr(docsrs, feature(doc_cfg))]
use crate::inner::Inner;
use crate::read::ReadHandle;
use crate::write::WriteHandle;
use left_right::aliasing::Aliased;
use std::collections::hash_map::RandomState;
use std::fmt;
use std::hash::{BuildHasher, Hash};
mod inner;
mod read;
mod stable_hash_eq;
mod values;
mod write;
pub use stable_hash_eq::StableHashEq;
/// Handles to the read and write halves of an `evmap`.
pub mod handles {
pub use crate::write::WriteHandle;
// These cannot use ::{..} syntax because of
// https://github.com/rust-lang/rust/issues/57411
pub use crate::read::ReadHandle;
pub use crate::read::ReadHandleFactory;
}
/// Helper types that give access to values inside the read half of an `evmap`.
pub mod refs {
// Same here, ::{..} won't work.
pub use super::values::Values;
pub use crate::read::MapReadRef;
pub use crate::read::ReadGuardIter;
// Expose `ReadGuard` since it has useful methods the user will likely care about.
#[doc(inline)]
pub use left_right::ReadGuard;
}
// NOTE: It is _critical_ that this module is not public.
mod aliasing;
/// Options for how to initialize the map.
///
/// In particular, the options dictate the hashing function, meta type, and initial capacity of the
/// map.
pub struct Options<M, S>
where
S: BuildHasher,
{
meta: M,
hasher: S,
capacity: Option<usize>,
}
impl<M, S> fmt::Debug for Options<M, S>
where
S: BuildHasher,
M: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Options")
.field("meta", &self.meta)
.field("capacity", &self.capacity)
.finish()
}
}
impl Default for Options<(), RandomState> {
fn default() -> Self {
Options {
meta: (),
hasher: RandomState::default(),
capacity: None,
}
}
}
impl<M, S> Options<M, S>
where
S: BuildHasher,
{
/// Set the initial meta value for the map.
pub fn with_meta<M2>(self, meta: M2) -> Options<M2, S> {
Options {
meta,
hasher: self.hasher,
capacity: self.capacity,
}
}
/// Set the hasher used for the map.
///
/// # Safety
///
/// This method is safe to call as long as the given hasher is deterministic. That is, it must
/// yield the same hash if given the same sequence of inputs.
pub unsafe fn with_hasher<S2>(self, hash_builder: S2) -> Options<M, S2>
where
S2: BuildHasher + Clone,
{
Options {
meta: self.meta,
hasher: hash_builder,
capacity: self.capacity,
}
}
/// Set the initial capacity for the map.
pub fn with_capacity(self, capacity: usize) -> Options<M, S> {
Options {
meta: self.meta,
hasher: self.hasher,
capacity: Some(capacity),
}
}
/// Create the map, and construct the read and write handles used to access it.
///
/// If you want to use arbitrary types for the keys and values, use [`assert_stable`][Options::assert_stable].
#[allow(clippy::type_complexity)]
pub fn construct<K, V>(self) -> (WriteHandle<K, V, M, S>, ReadHandle<K, V, M, S>)
where
K: StableHashEq + Clone,
S: BuildHasher + Clone,
V: StableHashEq,
M: 'static + Clone,
{
unsafe { self.assert_stable() }
}
/// Create the map, and construct the read and write handles used to access it.
///
/// # Safety
///
/// This method is safe to call as long as the implementation of `Hash` and `Eq` for both `K`
/// and `V` are deterministic. That is, they must always yield the same result if given the
/// same inputs. For keys of type `K`, the result must also be consistent between different clones
/// of the same key.
#[allow(clippy::type_complexity)]
pub unsafe fn assert_stable<K, V>(self) -> (WriteHandle<K, V, M, S>, ReadHandle<K, V, M, S>)
where
K: Eq + Hash + Clone,
S: BuildHasher + Clone,
V: Eq + Hash,
M: 'static + Clone,
| {
let inner = if let Some(cap) = self.capacity {
Inner::with_capacity_and_hasher(self.meta, cap, self.hasher)
} else {
Inner::with_hasher(self.meta, self.hasher)
};
let (mut w, r) = left_right::new_from_empty(inner);
w.append(write::Operation::MarkReady);
(WriteHandle::new(w), ReadHandle::new(r))
} | identifier_body | |
results.js | (options) {
// allow jQuery object to be passed in
// in case a different version of jQuery is needed from the one globally defined
$ = options.jQuery || $;
// Init data
// remove group not needed for the following visualizations
var work_ = options.work;
var groups_ = options.groups.filter(function(d) { return d.id !== "other"; });
var sources_ = options.sources;
var data = options.almStatsJson;
// Abort if data are missing
if (!data || !data[0]) {
console.log('Error: missing data');
d3.select("#loading-results").remove();
d3.select("#content-results").text("")
.insert("div")
.attr("class", "alert alert-info")
.text("There are currently no results");
return;
}
// Init basic options
var baseUrl_ = options.baseUrl;
var minItems_ = options.minItemsToShowGraph;
var formatNumber_ = d3.format(",d");
// extract publication date
// Construct date object from date parts, using "1" for missing day and month
var timestamp = Date.parse(work_["issued"]);
if (work_["issued"] === "0000") { timestamp = Date.parse("2000"); }
var pub_date = new Date(timestamp);
var vizDiv;
// Get the Div where the viz should go (default to one with ID "alm')
if (options.vizDiv) {
vizDiv = d3.select(options.vizDiv);
} else {
vizDiv = d3.select("#alm");
}
// look to make sure browser support SVG
var hasSVG_ = document.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1");
// to track if any metrics have been found
var metricsFound_;
/**
* Initialize the visualization.
* NB: needs to be accessible from the outside for initialization
*/
this.initViz = function() {
vizDiv.select("#loading-results").remove();
// loop through groups
groups_.forEach(function(group) {
addGroup_(vizDiv, group, sources_, data);
});
if (!metricsFound_) {
vizDiv.append("p")
.attr("class", "text-muted")
.text("No results found.");
}
};
/**
* Build each article level statistics group.
* @param {Object} canvas d3 element
* @param {Array} group Information about the group.
* @param {Object} data Statistics.
* @return {JQueryObject|boolean}
*/
var addGroup_ = function(canvas, group, sources_, data) {
var $groupRow = false;
// Loop through sources to add statistics data to the group.
sources_.forEach(function(source) {
if (source.group_id !== group.id) { return; }
results = data.filter(function(d) { return d.source_id === source.id; })[0];
if (typeof results === "undefined" || results.total === 0) { return; }
// Only add the group row the first time
if (!$groupRow) {
$groupRow = getgroupRow_(canvas, group);
}
// Flag that there is at least one metric
metricsFound_ = true;
var label = source.title;
addSource_(source, label, results, results.total, group, "total", $groupRow);
});
};
/**
* Get group row d3 HTML element. It will automatically
* add the element to the passed canvas.
* @param {d3Object} canvas d3 HTML element
* @param {Array} group group information.
* @param {d3Object}
*/
var getgroupRow_ = function(canvas, group) {
var groupRow, groupTitle, tooltip;
// Build group html objects.
groupRow = canvas.append("div")
.attr("class", "alm-group")
.attr("id", "group-" + group.id);
return groupRow;
};
/**
* Add source information to the passed group row element.
* @param {Object} source
* @param {integer} sourceTotalValue
* @param {Object} group
* @param {JQueryObject} $groupRow
* @return {JQueryObject}
*/
var addSource_ = function(source, label, results, sourceTotalValue, group, subgroup, $groupRow) {
var $row, $countLabel, $count,
total = sourceTotalValue;
$row = $groupRow
.append("div")
.attr("class", "alm-source")
.attr("id", "source-" + source.id + "-" + subgroup);
$countLabel = $row.append("div")
.attr("class", "alm-label " + group.id);
$count = $countLabel.append("p")
.attr("class", "alm-count")
.attr("id", "alm-count-" + source.id + "-" + group.id);
$count
.text(formatNumber_(total));
if (source.id === 'pkpTimedViews') {
$countLabel.append("p")
.text(label);
} else {
// link the source name
$countLabel.append("p").append("a")
.attr("href", baseUrl_ + "/sources/" + source.id)
.text(label);
}
// Only add a chart if the browser supports SVG
if (hasSVG_) {
var level = false;
// check what levels we can show
var showDaily = false;
var showMonthly = false;
var showYearly = false;
if (results.by_year) {
var level_data = getData_('year', results);
var yearTotal = level_data.reduce(function(i, d) { return i + d[subgroup]; }, 0);
var numYears = d3.time.year.utc.range(pub_date, new Date()).length;
if (yearTotal >= minItems_.minEventsForYearly &&
numYears >= minItems_.minYearsForYearly) {
showYearly = true;
level = 'year';
}
}
if (results.by_month) {
var level_data = getData_('month', results);
var monthTotal = level_data.reduce(function(i, d) { return i + d[subgroup]; }, 0);
var numMonths = d3.time.month.utc.range(pub_date, new Date()).length;
if (monthTotal >= minItems_.minEventsForMonthly &&
numMonths >= minItems_.minMonthsForMonthly) {
showMonthly = true;
level = 'month';
}
}
// The level and level_data should be set to the finest level
// of granularity that we can show
timeInterval = getTimeInterval_(level);
// check there is data for
if (showDaily || showMonthly || showYearly) {
$row
.attr('class', 'alm-source with-chart');
var $chartDiv = $row.append("div")
.attr("class", "alm-chart");
var viz = getViz_($chartDiv, source, group, subgroup, results);
loadData_(viz, level);
var update_controls = function(control) {
control.siblings('.alm-control').removeClass('active');
control.addClass('active');
};
var $levelControlsDiv = $chartDiv.append("div")
.attr("class", "alm-control-label")
.attr("style", "width: " + (viz.margin.left + viz.width) + "px;");
if (showDaily) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showDaily)
.classed("active", (level === 'day'))
.text("daily (first 30)")
.on("click", function() {
if (showDaily && !$(this).hasClass('active')) {
loadData_(viz, 'day');
update_controls($(this));
}
}
);
$levelControlsDiv.append("text").text(" | ");
}
if (showMonthly) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showMonthly || !showYearly)
.classed("active", (level === 'month'))
.text("monthly")
.on("click", function() { if (showMonthly && !$(this).hasClass('active')) {
loadData_(viz, 'month');
update_controls($(this));
} });
if (showYearly) {
$levelControlsDiv.append("text")
.text(" | ");
}
}
if (showYearly) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showYearly || !showMonthly)
.classed("active", (level === 'year'))
.text("yearly")
.on("click", function() {
if (showYearly && !$(this).hasClass('active')) {
loadData_(viz, 'year');
update_controls($(this | AlmViz | identifier_name | |
results.js | @return {JQueryObject}
*/
var addSource_ = function(source, label, results, sourceTotalValue, group, subgroup, $groupRow) {
var $row, $countLabel, $count,
total = sourceTotalValue;
$row = $groupRow
.append("div")
.attr("class", "alm-source")
.attr("id", "source-" + source.id + "-" + subgroup);
$countLabel = $row.append("div")
.attr("class", "alm-label " + group.id);
$count = $countLabel.append("p")
.attr("class", "alm-count")
.attr("id", "alm-count-" + source.id + "-" + group.id);
$count
.text(formatNumber_(total));
if (source.id === 'pkpTimedViews') {
$countLabel.append("p")
.text(label);
} else {
// link the source name
$countLabel.append("p").append("a")
.attr("href", baseUrl_ + "/sources/" + source.id)
.text(label);
}
// Only add a chart if the browser supports SVG
if (hasSVG_) {
var level = false;
// check what levels we can show
var showDaily = false;
var showMonthly = false;
var showYearly = false;
if (results.by_year) {
var level_data = getData_('year', results);
var yearTotal = level_data.reduce(function(i, d) { return i + d[subgroup]; }, 0);
var numYears = d3.time.year.utc.range(pub_date, new Date()).length;
if (yearTotal >= minItems_.minEventsForYearly &&
numYears >= minItems_.minYearsForYearly) {
showYearly = true;
level = 'year';
}
}
if (results.by_month) {
var level_data = getData_('month', results);
var monthTotal = level_data.reduce(function(i, d) { return i + d[subgroup]; }, 0);
var numMonths = d3.time.month.utc.range(pub_date, new Date()).length;
if (monthTotal >= minItems_.minEventsForMonthly &&
numMonths >= minItems_.minMonthsForMonthly) {
showMonthly = true;
level = 'month';
}
}
// The level and level_data should be set to the finest level
// of granularity that we can show
timeInterval = getTimeInterval_(level);
// check there is data for
if (showDaily || showMonthly || showYearly) {
$row
.attr('class', 'alm-source with-chart');
var $chartDiv = $row.append("div")
.attr("class", "alm-chart");
var viz = getViz_($chartDiv, source, group, subgroup, results);
loadData_(viz, level);
var update_controls = function(control) {
control.siblings('.alm-control').removeClass('active');
control.addClass('active');
};
var $levelControlsDiv = $chartDiv.append("div")
.attr("class", "alm-control-label")
.attr("style", "width: " + (viz.margin.left + viz.width) + "px;");
if (showDaily) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showDaily)
.classed("active", (level === 'day'))
.text("daily (first 30)")
.on("click", function() {
if (showDaily && !$(this).hasClass('active')) {
loadData_(viz, 'day');
update_controls($(this));
}
}
);
$levelControlsDiv.append("text").text(" | ");
}
if (showMonthly) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showMonthly || !showYearly)
.classed("active", (level === 'month'))
.text("monthly")
.on("click", function() { if (showMonthly && !$(this).hasClass('active')) {
loadData_(viz, 'month');
update_controls($(this));
} });
if (showYearly) {
$levelControlsDiv.append("text")
.text(" | ");
}
}
if (showYearly) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showYearly || !showMonthly)
.classed("active", (level === 'year'))
.text("yearly")
.on("click", function() {
if (showYearly && !$(this).hasClass('active')) {
loadData_(viz, 'year');
update_controls($(this));
}
}
);
}
}
}
return $row;
};
/**
* Extract the date from the source
* @param level (day|month|year)
* @param d the datum
* @return {Date}
*/
var getDate_ = function(level, d) {
switch (level) {
case 'year':
return new Date(d.year, 0, 1);
case 'month':
// js Date indexes months at 0
return new Date(d.year, d.month - 1, 1);
case 'day':
// js Date indexes months at 0
return new Date(d.year, d.month - 1, d.day);
}
};
/**
* Format the date for display
* @param level (day|month|year)
* @param d the datum
* @return {String}
*/
var getFormattedDate_ = function(level, d) {
switch (level) {
case 'year':
return d3.time.format("%Y")(getDate_(level, d));
case 'month':
return d3.time.format("%b %y")(getDate_(level, d));
case 'day':
return d3.time.format("%d %b %y")(getDate_(level, d));
}
};
/**
* Extract the data from the source.
* @param {string} level (day|month|year)
* @param {Object} source
* @return {Array} Metrics
*/
var getData_ = function(level, results) {
switch (level) {
case 'year':
return results.by_year;
case 'month':
return results.by_month;
}
};
/**
* Returns a d3 timeInterval for date operations.
* @param {string} level (day|month|year
* @return {Object} d3 time Interval
*/
var getTimeInterval_ = function(level) {
switch (level) {
case 'year':
return d3.time.year.utc;
case 'month':
return d3.time.month.utc;
case 'day':
return d3.time.day.utc;
}
};
/**
* The basic general set up of the graph itself
* @param {JQueryElement} chartDiv The div where the chart should go
* @param {Object} source
* @param {Array} group The group for 86 chart
* @return {Object}
*/
var getViz_ = function(chartDiv, source, group, subgroup, results) {
var viz = {};
// size parameters
viz.margin = {top: 10, right: 20, bottom: 5, left: 50};
viz.width = 760 - viz.margin.left - viz.margin.right;
viz.height = 115 - viz.margin.top - viz.margin.bottom;
// div where everything goes
viz.chartDiv = chartDiv;
// source data and which group
viz.group = group;
viz.subgroup = subgroup;
viz.source = source;
viz.results = results;
// just for record keeping
viz.name = source.id + '-' + group.id + '-' + viz.subgroup;
viz.x = d3.time.scale();
viz.x.range([0, viz.width]);
viz.y = d3.scale.linear();
viz.y.range([viz.height, 0]);
viz.z = d3.scale.ordinal();
viz.z.range([group.id, group.id + '-alt']);
// the chart
viz.svg = viz.chartDiv.append("svg")
.attr("width", viz.width + viz.margin.left + viz.margin.right)
.attr("height", viz.height + viz.margin.top + viz.margin.bottom + 1)
.append("g")
.attr("transform", "translate(" + viz.margin.left + "," + viz.margin.top + ")");
// draw the bars g first so it ends up underneath the axes
viz.bars = viz.svg.append("g");
// and the shadow bars on top for the tooltips
viz.barsForTooltips = viz.svg.append("g");
viz.svg.append("g")
.attr("class", "x axis")
.attr("transform", "translate(0," + viz.height + ")");
| viz.svg.append("g")
.attr("class", "y axis"); | random_line_split | |
results.js | .attr("class", "alert alert-info")
.text("There are currently no results");
return;
}
// Init basic options
var baseUrl_ = options.baseUrl;
var minItems_ = options.minItemsToShowGraph;
var formatNumber_ = d3.format(",d");
// extract publication date
// Construct date object from date parts, using "1" for missing day and month
var timestamp = Date.parse(work_["issued"]);
if (work_["issued"] === "0000") { timestamp = Date.parse("2000"); }
var pub_date = new Date(timestamp);
var vizDiv;
// Get the Div where the viz should go (default to one with ID "alm')
if (options.vizDiv) {
vizDiv = d3.select(options.vizDiv);
} else {
vizDiv = d3.select("#alm");
}
// look to make sure browser support SVG
var hasSVG_ = document.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1");
// to track if any metrics have been found
var metricsFound_;
/**
* Initialize the visualization.
* NB: needs to be accessible from the outside for initialization
*/
this.initViz = function() {
vizDiv.select("#loading-results").remove();
// loop through groups
groups_.forEach(function(group) {
addGroup_(vizDiv, group, sources_, data);
});
if (!metricsFound_) {
vizDiv.append("p")
.attr("class", "text-muted")
.text("No results found.");
}
};
/**
* Build each article level statistics group.
* @param {Object} canvas d3 element
* @param {Array} group Information about the group.
* @param {Object} data Statistics.
* @return {JQueryObject|boolean}
*/
var addGroup_ = function(canvas, group, sources_, data) {
var $groupRow = false;
// Loop through sources to add statistics data to the group.
sources_.forEach(function(source) {
if (source.group_id !== group.id) { return; }
results = data.filter(function(d) { return d.source_id === source.id; })[0];
if (typeof results === "undefined" || results.total === 0) { return; }
// Only add the group row the first time
if (!$groupRow) {
$groupRow = getgroupRow_(canvas, group);
}
// Flag that there is at least one metric
metricsFound_ = true;
var label = source.title;
addSource_(source, label, results, results.total, group, "total", $groupRow);
});
};
/**
* Get group row d3 HTML element. It will automatically
* add the element to the passed canvas.
* @param {d3Object} canvas d3 HTML element
* @param {Array} group group information.
* @param {d3Object}
*/
var getgroupRow_ = function(canvas, group) {
var groupRow, groupTitle, tooltip;
// Build group html objects.
groupRow = canvas.append("div")
.attr("class", "alm-group")
.attr("id", "group-" + group.id);
return groupRow;
};
/**
* Add source information to the passed group row element.
* @param {Object} source
* @param {integer} sourceTotalValue
* @param {Object} group
* @param {JQueryObject} $groupRow
* @return {JQueryObject}
*/
var addSource_ = function(source, label, results, sourceTotalValue, group, subgroup, $groupRow) {
var $row, $countLabel, $count,
total = sourceTotalValue;
$row = $groupRow
.append("div")
.attr("class", "alm-source")
.attr("id", "source-" + source.id + "-" + subgroup);
$countLabel = $row.append("div")
.attr("class", "alm-label " + group.id);
$count = $countLabel.append("p")
.attr("class", "alm-count")
.attr("id", "alm-count-" + source.id + "-" + group.id);
$count
.text(formatNumber_(total));
if (source.id === 'pkpTimedViews') {
$countLabel.append("p")
.text(label);
} else {
// link the source name
$countLabel.append("p").append("a")
.attr("href", baseUrl_ + "/sources/" + source.id)
.text(label);
}
// Only add a chart if the browser supports SVG
if (hasSVG_) {
var level = false;
// check what levels we can show
var showDaily = false;
var showMonthly = false;
var showYearly = false;
if (results.by_year) {
var level_data = getData_('year', results);
var yearTotal = level_data.reduce(function(i, d) { return i + d[subgroup]; }, 0);
var numYears = d3.time.year.utc.range(pub_date, new Date()).length;
if (yearTotal >= minItems_.minEventsForYearly &&
numYears >= minItems_.minYearsForYearly) {
showYearly = true;
level = 'year';
}
}
if (results.by_month) {
var level_data = getData_('month', results);
var monthTotal = level_data.reduce(function(i, d) { return i + d[subgroup]; }, 0);
var numMonths = d3.time.month.utc.range(pub_date, new Date()).length;
if (monthTotal >= minItems_.minEventsForMonthly &&
numMonths >= minItems_.minMonthsForMonthly) {
showMonthly = true;
level = 'month';
}
}
// The level and level_data should be set to the finest level
// of granularity that we can show
timeInterval = getTimeInterval_(level);
// check there is data for
if (showDaily || showMonthly || showYearly) {
$row
.attr('class', 'alm-source with-chart');
var $chartDiv = $row.append("div")
.attr("class", "alm-chart");
var viz = getViz_($chartDiv, source, group, subgroup, results);
loadData_(viz, level);
var update_controls = function(control) {
control.siblings('.alm-control').removeClass('active');
control.addClass('active');
};
var $levelControlsDiv = $chartDiv.append("div")
.attr("class", "alm-control-label")
.attr("style", "width: " + (viz.margin.left + viz.width) + "px;");
if (showDaily) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showDaily)
.classed("active", (level === 'day'))
.text("daily (first 30)")
.on("click", function() {
if (showDaily && !$(this).hasClass('active')) {
loadData_(viz, 'day');
update_controls($(this));
}
}
);
$levelControlsDiv.append("text").text(" | ");
}
if (showMonthly) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showMonthly || !showYearly)
.classed("active", (level === 'month'))
.text("monthly")
.on("click", function() { if (showMonthly && !$(this).hasClass('active')) {
loadData_(viz, 'month');
update_controls($(this));
} });
if (showYearly) {
$levelControlsDiv.append("text")
.text(" | ");
}
}
if (showYearly) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showYearly || !showMonthly)
.classed("active", (level === 'year'))
.text("yearly")
.on("click", function() {
if (showYearly && !$(this).hasClass('active')) {
loadData_(viz, 'year');
update_controls($(this));
}
}
| {
// allow jQuery object to be passed in
// in case a different version of jQuery is needed from the one globally defined
$ = options.jQuery || $;
// Init data
// remove group not needed for the following visualizations
var work_ = options.work;
var groups_ = options.groups.filter(function(d) { return d.id !== "other"; });
var sources_ = options.sources;
var data = options.almStatsJson;
// Abort if data are missing
if (!data || !data[0]) {
console.log('Error: missing data');
d3.select("#loading-results").remove();
d3.select("#content-results").text("")
.insert("div") | identifier_body | |
results.js | } else |
// look to make sure browser support SVG
var hasSVG_ = document.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1");
// to track if any metrics have been found
var metricsFound_;
/**
* Initialize the visualization.
* NB: needs to be accessible from the outside for initialization
*/
this.initViz = function() {
vizDiv.select("#loading-results").remove();
// loop through groups
groups_.forEach(function(group) {
addGroup_(vizDiv, group, sources_, data);
});
if (!metricsFound_) {
vizDiv.append("p")
.attr("class", "text-muted")
.text("No results found.");
}
};
/**
* Build each article level statistics group.
* @param {Object} canvas d3 element
* @param {Array} group Information about the group.
* @param {Object} data Statistics.
* @return {JQueryObject|boolean}
*/
var addGroup_ = function(canvas, group, sources_, data) {
var $groupRow = false;
// Loop through sources to add statistics data to the group.
sources_.forEach(function(source) {
if (source.group_id !== group.id) { return; }
results = data.filter(function(d) { return d.source_id === source.id; })[0];
if (typeof results === "undefined" || results.total === 0) { return; }
// Only add the group row the first time
if (!$groupRow) {
$groupRow = getgroupRow_(canvas, group);
}
// Flag that there is at least one metric
metricsFound_ = true;
var label = source.title;
addSource_(source, label, results, results.total, group, "total", $groupRow);
});
};
/**
* Get group row d3 HTML element. It will automatically
* add the element to the passed canvas.
* @param {d3Object} canvas d3 HTML element
* @param {Array} group group information.
* @param {d3Object}
*/
var getgroupRow_ = function(canvas, group) {
var groupRow, groupTitle, tooltip;
// Build group html objects.
groupRow = canvas.append("div")
.attr("class", "alm-group")
.attr("id", "group-" + group.id);
return groupRow;
};
/**
* Add source information to the passed group row element.
* @param {Object} source
* @param {integer} sourceTotalValue
* @param {Object} group
* @param {JQueryObject} $groupRow
* @return {JQueryObject}
*/
var addSource_ = function(source, label, results, sourceTotalValue, group, subgroup, $groupRow) {
var $row, $countLabel, $count,
total = sourceTotalValue;
$row = $groupRow
.append("div")
.attr("class", "alm-source")
.attr("id", "source-" + source.id + "-" + subgroup);
$countLabel = $row.append("div")
.attr("class", "alm-label " + group.id);
$count = $countLabel.append("p")
.attr("class", "alm-count")
.attr("id", "alm-count-" + source.id + "-" + group.id);
$count
.text(formatNumber_(total));
if (source.id === 'pkpTimedViews') {
$countLabel.append("p")
.text(label);
} else {
// link the source name
$countLabel.append("p").append("a")
.attr("href", baseUrl_ + "/sources/" + source.id)
.text(label);
}
// Only add a chart if the browser supports SVG
if (hasSVG_) {
var level = false;
// check what levels we can show
var showDaily = false;
var showMonthly = false;
var showYearly = false;
if (results.by_year) {
var level_data = getData_('year', results);
var yearTotal = level_data.reduce(function(i, d) { return i + d[subgroup]; }, 0);
var numYears = d3.time.year.utc.range(pub_date, new Date()).length;
if (yearTotal >= minItems_.minEventsForYearly &&
numYears >= minItems_.minYearsForYearly) {
showYearly = true;
level = 'year';
}
}
if (results.by_month) {
var level_data = getData_('month', results);
var monthTotal = level_data.reduce(function(i, d) { return i + d[subgroup]; }, 0);
var numMonths = d3.time.month.utc.range(pub_date, new Date()).length;
if (monthTotal >= minItems_.minEventsForMonthly &&
numMonths >= minItems_.minMonthsForMonthly) {
showMonthly = true;
level = 'month';
}
}
// The level and level_data should be set to the finest level
// of granularity that we can show
timeInterval = getTimeInterval_(level);
// check there is data for
if (showDaily || showMonthly || showYearly) {
$row
.attr('class', 'alm-source with-chart');
var $chartDiv = $row.append("div")
.attr("class", "alm-chart");
var viz = getViz_($chartDiv, source, group, subgroup, results);
loadData_(viz, level);
var update_controls = function(control) {
control.siblings('.alm-control').removeClass('active');
control.addClass('active');
};
var $levelControlsDiv = $chartDiv.append("div")
.attr("class", "alm-control-label")
.attr("style", "width: " + (viz.margin.left + viz.width) + "px;");
if (showDaily) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showDaily)
.classed("active", (level === 'day'))
.text("daily (first 30)")
.on("click", function() {
if (showDaily && !$(this).hasClass('active')) {
loadData_(viz, 'day');
update_controls($(this));
}
}
);
$levelControlsDiv.append("text").text(" | ");
}
if (showMonthly) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showMonthly || !showYearly)
.classed("active", (level === 'month'))
.text("monthly")
.on("click", function() { if (showMonthly && !$(this).hasClass('active')) {
loadData_(viz, 'month');
update_controls($(this));
} });
if (showYearly) {
$levelControlsDiv.append("text")
.text(" | ");
}
}
if (showYearly) {
$levelControlsDiv.append("a")
.attr("href", "javascript:void(0)")
.classed("alm-control", true)
.classed("disabled", !showYearly || !showMonthly)
.classed("active", (level === 'year'))
.text("yearly")
.on("click", function() {
if (showYearly && !$(this).hasClass('active')) {
loadData_(viz, 'year');
update_controls($(this));
}
}
);
}
}
}
return $row;
};
/**
* Extract the date from the source
* @param level (day|month|year)
* @param d the datum
* @return {Date}
*/
var getDate_ = function(level, d) {
switch (level) {
case 'year':
return new Date(d.year, 0, 1);
case 'month':
// js Date indexes months at 0
return new Date(d.year, d.month - 1, 1);
case 'day':
// js Date indexes months at 0
return new Date(d.year, d.month - 1, d.day);
}
};
/**
* Format the date for display
* @param level (day|month|year)
* @param d the datum
* @return {String}
*/
var getFormattedDate_ = function(level, d) {
switch (level) {
case 'year':
return d3.time.format("%Y")(getDate_(level, d));
case 'month':
return d3.time.format("%b %y")(getDate_(level, d));
case 'day':
return d3.time.format("%d %b %y")(getDate_(level, d));
}
};
/**
* Extract the data from the source.
* @param {string} level (day|month|year)
* @param {Object} source
* @return {Array} Metrics
*/
var getData_ | {
vizDiv = d3.select("#alm");
} | conditional_block |
provider.go | : true,
DefaultFunc: schema.EnvDefaultFunc("ARM_ENVIRONMENT", "public"),
},
"skip_provider_registration": {
Type: schema.TypeBool,
Optional: true, | DefaultFunc: schema.EnvDefaultFunc("ARM_SKIP_PROVIDER_REGISTRATION", false),
},
},
DataSourcesMap: map[string]*schema.Resource{
"azurerm_client_config": dataSourceArmClientConfig(),
},
ResourcesMap: map[string]*schema.Resource{
// These resources use the Azure ARM SDK
"azurerm_availability_set": resourceArmAvailabilitySet(),
"azurerm_cdn_endpoint": resourceArmCdnEndpoint(),
"azurerm_cdn_profile": resourceArmCdnProfile(),
"azurerm_container_registry": resourceArmContainerRegistry(),
"azurerm_container_service": resourceArmContainerService(),
"azurerm_eventhub": resourceArmEventHub(),
"azurerm_eventhub_authorization_rule": resourceArmEventHubAuthorizationRule(),
"azurerm_eventhub_consumer_group": resourceArmEventHubConsumerGroup(),
"azurerm_eventhub_namespace": resourceArmEventHubNamespace(),
"azurerm_lb": resourceArmLoadBalancer(),
"azurerm_lb_backend_address_pool": resourceArmLoadBalancerBackendAddressPool(),
"azurerm_lb_nat_rule": resourceArmLoadBalancerNatRule(),
"azurerm_lb_nat_pool": resourceArmLoadBalancerNatPool(),
"azurerm_lb_probe": resourceArmLoadBalancerProbe(),
"azurerm_lb_rule": resourceArmLoadBalancerRule(),
"azurerm_managed_disk": resourceArmManagedDisk(),
"azurerm_key_vault": resourceArmKeyVault(),
"azurerm_local_network_gateway": resourceArmLocalNetworkGateway(),
"azurerm_network_interface": resourceArmNetworkInterface(),
"azurerm_network_security_group": resourceArmNetworkSecurityGroup(),
"azurerm_network_security_rule": resourceArmNetworkSecurityRule(),
"azurerm_public_ip": resourceArmPublicIp(),
"azurerm_redis_cache": resourceArmRedisCache(),
"azurerm_route": resourceArmRoute(),
"azurerm_route_table": resourceArmRouteTable(),
"azurerm_servicebus_namespace": resourceArmServiceBusNamespace(),
"azurerm_servicebus_subscription": resourceArmServiceBusSubscription(),
"azurerm_servicebus_topic": resourceArmServiceBusTopic(),
"azurerm_storage_account": resourceArmStorageAccount(),
"azurerm_storage_blob": resourceArmStorageBlob(),
"azurerm_storage_container": resourceArmStorageContainer(),
"azurerm_storage_share": resourceArmStorageShare(),
"azurerm_storage_queue": resourceArmStorageQueue(),
"azurerm_storage_table": resourceArmStorageTable(),
"azurerm_subnet": resourceArmSubnet(),
"azurerm_template_deployment": resourceArmTemplateDeployment(),
"azurerm_traffic_manager_endpoint": resourceArmTrafficManagerEndpoint(),
"azurerm_traffic_manager_profile": resourceArmTrafficManagerProfile(),
"azurerm_virtual_machine_extension": resourceArmVirtualMachineExtensions(),
"azurerm_virtual_machine": resourceArmVirtualMachine(),
"azurerm_virtual_machine_scale_set": resourceArmVirtualMachineScaleSet(),
"azurerm_virtual_network": resourceArmVirtualNetwork(),
"azurerm_virtual_network_peering": resourceArmVirtualNetworkPeering(),
// These resources use the Riviera SDK
"azurerm_dns_a_record": resourceArmDnsARecord(),
"azurerm_dns_aaaa_record": resourceArmDnsAAAARecord(),
"azurerm_dns_cname_record": resourceArmDnsCNameRecord(),
"azurerm_dns_mx_record": resourceArmDnsMxRecord(),
"azurerm_dns_ns_record": resourceArmDnsNsRecord(),
"azurerm_dns_srv_record": resourceArmDnsSrvRecord(),
"azurerm_dns_txt_record": resourceArmDnsTxtRecord(),
"azurerm_dns_zone": resourceArmDnsZone(),
"azurerm_resource_group": resourceArmResourceGroup(),
"azurerm_search_service": resourceArmSearchService(),
"azurerm_sql_database": resourceArmSqlDatabase(),
"azurerm_sql_firewall_rule": resourceArmSqlFirewallRule(),
"azurerm_sql_server": resourceArmSqlServer(),
},
}
p.ConfigureFunc = providerConfigure(p)
return p
}
// Config is the configuration structure used to instantiate a
// new Azure management client.
type Config struct {
ManagementURL string
SubscriptionID string
ClientID string
ClientSecret string
TenantID string
Environment string
SkipProviderRegistration bool
validateCredentialsOnce sync.Once
}
func (c *Config) validate() error {
var err *multierror.Error
if c.SubscriptionID == "" {
err = multierror.Append(err, fmt.Errorf("Subscription ID must be configured for the AzureRM provider"))
}
if c.ClientID == "" {
err = multierror.Append(err, fmt.Errorf("Client ID must be configured for the AzureRM provider"))
}
if c.ClientSecret == "" {
err = multierror.Append(err, fmt.Errorf("Client Secret must be configured for the AzureRM provider"))
}
if c.TenantID == "" {
err = multierror.Append(err, fmt.Errorf("Tenant ID must be configured for the AzureRM provider"))
}
if c.Environment == "" {
err = multierror.Append(err, fmt.Errorf("Environment must be configured for the AzureRM provider"))
}
return err.ErrorOrNil()
}
func providerConfigure(p *schema.Provider) schema.ConfigureFunc {
return func(d *schema.ResourceData) (interface{}, error) {
config := &Config{
SubscriptionID: d.Get("subscription_id").(string),
ClientID: d.Get("client_id").(string),
ClientSecret: d.Get("client_secret").(string),
TenantID: d.Get("tenant_id").(string),
Environment: d.Get("environment").(string),
SkipProviderRegistration: d.Get("skip_provider_registration").(bool),
}
if err := config.validate(); err != nil {
return nil, err
}
client, err := config.getArmClient()
if err != nil {
return nil, err
}
client.StopContext = p.StopContext()
// replaces the context between tests
p.MetaReset = func() error {
client.StopContext = p.StopContext()
return nil
}
// List all the available providers and their registration state to avoid unnecessary
// requests. This also lets us check if the provider credentials are correct.
providerList, err := client.providers.List(nil, "")
if err != nil {
return nil, fmt.Errorf("Unable to list provider registration status, it is possible that this is due to invalid "+
"credentials or the service principal does not have permission to use the Resource Manager API, Azure "+
"error: %s", err)
}
if !config.SkipProviderRegistration {
err = registerAzureResourceProvidersWithSubscription(*providerList.Value, client.providers)
if err != nil {
return nil, err
}
}
return client, nil
}
}
func registerProviderWithSubscription(providerName string, client resources.ProvidersClient) error {
_, err := client.Register(providerName)
if err != nil {
return fmt.Errorf("Cannot register provider %s with Azure Resource Manager: %s.", providerName, err)
}
return nil
}
var providerRegistrationOnce sync.Once
// registerAzureResourceProvidersWithSubscription uses the providers client to register
// all Azure resource providers which the Terraform provider may require (regardless of
// whether they are actually used by the configuration or not). It was confirmed by Microsoft
// that this is the approach their own internal tools also take.
func registerAzureResourceProvidersWithSubscription(providerList []resources.Provider, client resources.ProvidersClient) error {
var err error
providerRegistrationOnce.Do(func() {
providers := map[string]struct{}{
"Microsoft.Compute": struct{}{},
"Microsoft.Cache": struct{}{},
"Microsoft.ContainerRegistry": struct{}{},
"Microsoft.ContainerService": struct{}{},
"Microsoft.Network": struct{}{},
"Microsoft.Cdn": struct{}{},
"Microsoft.Storage": struct{}{},
"Microsoft.Sql": struct{}{},
"Microsoft.Search": struct{}{},
"Microsoft.Resources": struct{}{},
"Microsoft.ServiceBus": struct{}{},
"Microsoft.KeyVault": struct{}{},
"Microsoft.EventHub": struct{}{},
}
// filter out any providers already registered
for _, p := range providerList {
if _, ok := providers[*p.Namespace]; !ok {
continue
}
if strings.ToLower(*p.RegistrationState) == "registered" {
log.Printf("[DEBUG] Skipping | random_line_split | |
provider.go | StorageQueue(),
"azurerm_storage_table": resourceArmStorageTable(),
"azurerm_subnet": resourceArmSubnet(),
"azurerm_template_deployment": resourceArmTemplateDeployment(),
"azurerm_traffic_manager_endpoint": resourceArmTrafficManagerEndpoint(),
"azurerm_traffic_manager_profile": resourceArmTrafficManagerProfile(),
"azurerm_virtual_machine_extension": resourceArmVirtualMachineExtensions(),
"azurerm_virtual_machine": resourceArmVirtualMachine(),
"azurerm_virtual_machine_scale_set": resourceArmVirtualMachineScaleSet(),
"azurerm_virtual_network": resourceArmVirtualNetwork(),
"azurerm_virtual_network_peering": resourceArmVirtualNetworkPeering(),
// These resources use the Riviera SDK
"azurerm_dns_a_record": resourceArmDnsARecord(),
"azurerm_dns_aaaa_record": resourceArmDnsAAAARecord(),
"azurerm_dns_cname_record": resourceArmDnsCNameRecord(),
"azurerm_dns_mx_record": resourceArmDnsMxRecord(),
"azurerm_dns_ns_record": resourceArmDnsNsRecord(),
"azurerm_dns_srv_record": resourceArmDnsSrvRecord(),
"azurerm_dns_txt_record": resourceArmDnsTxtRecord(),
"azurerm_dns_zone": resourceArmDnsZone(),
"azurerm_resource_group": resourceArmResourceGroup(),
"azurerm_search_service": resourceArmSearchService(),
"azurerm_sql_database": resourceArmSqlDatabase(),
"azurerm_sql_firewall_rule": resourceArmSqlFirewallRule(),
"azurerm_sql_server": resourceArmSqlServer(),
},
}
p.ConfigureFunc = providerConfigure(p)
return p
}
// Config is the configuration structure used to instantiate a
// new Azure management client.
type Config struct {
ManagementURL string
SubscriptionID string
ClientID string
ClientSecret string
TenantID string
Environment string
SkipProviderRegistration bool
validateCredentialsOnce sync.Once
}
func (c *Config) validate() error {
var err *multierror.Error
if c.SubscriptionID == "" {
err = multierror.Append(err, fmt.Errorf("Subscription ID must be configured for the AzureRM provider"))
}
if c.ClientID == "" {
err = multierror.Append(err, fmt.Errorf("Client ID must be configured for the AzureRM provider"))
}
if c.ClientSecret == "" {
err = multierror.Append(err, fmt.Errorf("Client Secret must be configured for the AzureRM provider"))
}
if c.TenantID == "" {
err = multierror.Append(err, fmt.Errorf("Tenant ID must be configured for the AzureRM provider"))
}
if c.Environment == "" {
err = multierror.Append(err, fmt.Errorf("Environment must be configured for the AzureRM provider"))
}
return err.ErrorOrNil()
}
func providerConfigure(p *schema.Provider) schema.ConfigureFunc {
return func(d *schema.ResourceData) (interface{}, error) {
config := &Config{
SubscriptionID: d.Get("subscription_id").(string),
ClientID: d.Get("client_id").(string),
ClientSecret: d.Get("client_secret").(string),
TenantID: d.Get("tenant_id").(string),
Environment: d.Get("environment").(string),
SkipProviderRegistration: d.Get("skip_provider_registration").(bool),
}
if err := config.validate(); err != nil {
return nil, err
}
client, err := config.getArmClient()
if err != nil {
return nil, err
}
client.StopContext = p.StopContext()
// replaces the context between tests
p.MetaReset = func() error {
client.StopContext = p.StopContext()
return nil
}
// List all the available providers and their registration state to avoid unnecessary
// requests. This also lets us check if the provider credentials are correct.
providerList, err := client.providers.List(nil, "")
if err != nil {
return nil, fmt.Errorf("Unable to list provider registration status, it is possible that this is due to invalid "+
"credentials or the service principal does not have permission to use the Resource Manager API, Azure "+
"error: %s", err)
}
if !config.SkipProviderRegistration {
err = registerAzureResourceProvidersWithSubscription(*providerList.Value, client.providers)
if err != nil {
return nil, err
}
}
return client, nil
}
}
func registerProviderWithSubscription(providerName string, client resources.ProvidersClient) error {
_, err := client.Register(providerName)
if err != nil {
return fmt.Errorf("Cannot register provider %s with Azure Resource Manager: %s.", providerName, err)
}
return nil
}
var providerRegistrationOnce sync.Once
// registerAzureResourceProvidersWithSubscription uses the providers client to register
// all Azure resource providers which the Terraform provider may require (regardless of
// whether they are actually used by the configuration or not). It was confirmed by Microsoft
// that this is the approach their own internal tools also take.
func registerAzureResourceProvidersWithSubscription(providerList []resources.Provider, client resources.ProvidersClient) error {
var err error
providerRegistrationOnce.Do(func() {
providers := map[string]struct{}{
"Microsoft.Compute": struct{}{},
"Microsoft.Cache": struct{}{},
"Microsoft.ContainerRegistry": struct{}{},
"Microsoft.ContainerService": struct{}{},
"Microsoft.Network": struct{}{},
"Microsoft.Cdn": struct{}{},
"Microsoft.Storage": struct{}{},
"Microsoft.Sql": struct{}{},
"Microsoft.Search": struct{}{},
"Microsoft.Resources": struct{}{},
"Microsoft.ServiceBus": struct{}{},
"Microsoft.KeyVault": struct{}{},
"Microsoft.EventHub": struct{}{},
}
// filter out any providers already registered
for _, p := range providerList {
if _, ok := providers[*p.Namespace]; !ok {
continue
}
if strings.ToLower(*p.RegistrationState) == "registered" {
log.Printf("[DEBUG] Skipping provider registration for namespace %s\n", *p.Namespace)
delete(providers, *p.Namespace)
}
}
var wg sync.WaitGroup
wg.Add(len(providers))
for providerName := range providers {
go func(p string) {
defer wg.Done()
log.Printf("[DEBUG] Registering provider with namespace %s\n", p)
if innerErr := registerProviderWithSubscription(p, client); err != nil {
err = innerErr
}
}(providerName)
}
wg.Wait()
})
return err
}
// armMutexKV is the instance of MutexKV for ARM resources
var armMutexKV = mutexkv.NewMutexKV()
func azureStateRefreshFunc(resourceURI string, client *ArmClient, command riviera.APICall) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
req := client.rivieraClient.NewRequestForURI(resourceURI)
req.Command = command
res, err := req.Execute()
if err != nil {
return nil, "", fmt.Errorf("Error executing %T command in azureStateRefreshFunc", req.Command)
}
var value reflect.Value
if reflect.ValueOf(res.Parsed).Kind() == reflect.Ptr {
value = reflect.ValueOf(res.Parsed).Elem()
} else {
value = reflect.ValueOf(res.Parsed)
}
for i := 0; i < value.NumField(); i++ { // iterates through every struct type field
tag := value.Type().Field(i).Tag // returns the tag string
tagValue := tag.Get("mapstructure")
if tagValue == "provisioningState" {
return res.Parsed, value.Field(i).Elem().String(), nil
}
}
panic(fmt.Errorf("azureStateRefreshFunc called on structure %T with no mapstructure:provisioningState tag. This is a bug", res.Parsed))
}
}
// Resource group names can be capitalised, but we store them in lowercase.
// Use a custom diff function to avoid creation of new resources.
func resourceAzurermResourceGroupNameDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
return strings.ToLower(old) == strings.ToLower(new)
}
// ignoreCaseDiffSuppressFunc is a DiffSuppressFunc from helper/schema that is
// used to ignore any case-changes in a return value.
func ignoreCaseDiffSuppressFunc(k, old, new string, d *schema.ResourceData) bool {
return strings.ToLower(old) == strings.ToLower(new)
}
// ignoreCaseStateFunc is a StateFunc from helper/schema that converts the
// supplied value to lower before saving to state for consistency.
func ignoreCaseStateFunc(val interface{}) string {
return strings.ToLower(val.(string))
}
func userDataStateFunc(v interface{}) string | {
switch s := v.(type) {
case string:
s = base64Encode(s)
hash := sha1.Sum([]byte(s))
return hex.EncodeToString(hash[:])
default:
return ""
}
} | identifier_body | |
provider.go | : true,
DefaultFunc: schema.EnvDefaultFunc("ARM_ENVIRONMENT", "public"),
},
"skip_provider_registration": {
Type: schema.TypeBool,
Optional: true,
DefaultFunc: schema.EnvDefaultFunc("ARM_SKIP_PROVIDER_REGISTRATION", false),
},
},
DataSourcesMap: map[string]*schema.Resource{
"azurerm_client_config": dataSourceArmClientConfig(),
},
ResourcesMap: map[string]*schema.Resource{
// These resources use the Azure ARM SDK
"azurerm_availability_set": resourceArmAvailabilitySet(),
"azurerm_cdn_endpoint": resourceArmCdnEndpoint(),
"azurerm_cdn_profile": resourceArmCdnProfile(),
"azurerm_container_registry": resourceArmContainerRegistry(),
"azurerm_container_service": resourceArmContainerService(),
"azurerm_eventhub": resourceArmEventHub(),
"azurerm_eventhub_authorization_rule": resourceArmEventHubAuthorizationRule(),
"azurerm_eventhub_consumer_group": resourceArmEventHubConsumerGroup(),
"azurerm_eventhub_namespace": resourceArmEventHubNamespace(),
"azurerm_lb": resourceArmLoadBalancer(),
"azurerm_lb_backend_address_pool": resourceArmLoadBalancerBackendAddressPool(),
"azurerm_lb_nat_rule": resourceArmLoadBalancerNatRule(),
"azurerm_lb_nat_pool": resourceArmLoadBalancerNatPool(),
"azurerm_lb_probe": resourceArmLoadBalancerProbe(),
"azurerm_lb_rule": resourceArmLoadBalancerRule(),
"azurerm_managed_disk": resourceArmManagedDisk(),
"azurerm_key_vault": resourceArmKeyVault(),
"azurerm_local_network_gateway": resourceArmLocalNetworkGateway(),
"azurerm_network_interface": resourceArmNetworkInterface(),
"azurerm_network_security_group": resourceArmNetworkSecurityGroup(),
"azurerm_network_security_rule": resourceArmNetworkSecurityRule(),
"azurerm_public_ip": resourceArmPublicIp(),
"azurerm_redis_cache": resourceArmRedisCache(),
"azurerm_route": resourceArmRoute(),
"azurerm_route_table": resourceArmRouteTable(),
"azurerm_servicebus_namespace": resourceArmServiceBusNamespace(),
"azurerm_servicebus_subscription": resourceArmServiceBusSubscription(),
"azurerm_servicebus_topic": resourceArmServiceBusTopic(),
"azurerm_storage_account": resourceArmStorageAccount(),
"azurerm_storage_blob": resourceArmStorageBlob(),
"azurerm_storage_container": resourceArmStorageContainer(),
"azurerm_storage_share": resourceArmStorageShare(),
"azurerm_storage_queue": resourceArmStorageQueue(),
"azurerm_storage_table": resourceArmStorageTable(),
"azurerm_subnet": resourceArmSubnet(),
"azurerm_template_deployment": resourceArmTemplateDeployment(),
"azurerm_traffic_manager_endpoint": resourceArmTrafficManagerEndpoint(),
"azurerm_traffic_manager_profile": resourceArmTrafficManagerProfile(),
"azurerm_virtual_machine_extension": resourceArmVirtualMachineExtensions(),
"azurerm_virtual_machine": resourceArmVirtualMachine(),
"azurerm_virtual_machine_scale_set": resourceArmVirtualMachineScaleSet(),
"azurerm_virtual_network": resourceArmVirtualNetwork(),
"azurerm_virtual_network_peering": resourceArmVirtualNetworkPeering(),
// These resources use the Riviera SDK
"azurerm_dns_a_record": resourceArmDnsARecord(),
"azurerm_dns_aaaa_record": resourceArmDnsAAAARecord(),
"azurerm_dns_cname_record": resourceArmDnsCNameRecord(),
"azurerm_dns_mx_record": resourceArmDnsMxRecord(),
"azurerm_dns_ns_record": resourceArmDnsNsRecord(),
"azurerm_dns_srv_record": resourceArmDnsSrvRecord(),
"azurerm_dns_txt_record": resourceArmDnsTxtRecord(),
"azurerm_dns_zone": resourceArmDnsZone(),
"azurerm_resource_group": resourceArmResourceGroup(),
"azurerm_search_service": resourceArmSearchService(),
"azurerm_sql_database": resourceArmSqlDatabase(),
"azurerm_sql_firewall_rule": resourceArmSqlFirewallRule(),
"azurerm_sql_server": resourceArmSqlServer(),
},
}
p.ConfigureFunc = providerConfigure(p)
return p
}
// Config is the configuration structure used to instantiate a
// new Azure management client.
type Config struct {
ManagementURL string
SubscriptionID string
ClientID string
ClientSecret string
TenantID string
Environment string
SkipProviderRegistration bool
validateCredentialsOnce sync.Once
}
func (c *Config) validate() error {
var err *multierror.Error
if c.SubscriptionID == "" {
err = multierror.Append(err, fmt.Errorf("Subscription ID must be configured for the AzureRM provider"))
}
if c.ClientID == "" {
err = multierror.Append(err, fmt.Errorf("Client ID must be configured for the AzureRM provider"))
}
if c.ClientSecret == "" {
err = multierror.Append(err, fmt.Errorf("Client Secret must be configured for the AzureRM provider"))
}
if c.TenantID == "" {
err = multierror.Append(err, fmt.Errorf("Tenant ID must be configured for the AzureRM provider"))
}
if c.Environment == "" {
err = multierror.Append(err, fmt.Errorf("Environment must be configured for the AzureRM provider"))
}
return err.ErrorOrNil()
}
func providerConfigure(p *schema.Provider) schema.ConfigureFunc {
return func(d *schema.ResourceData) (interface{}, error) {
config := &Config{
SubscriptionID: d.Get("subscription_id").(string),
ClientID: d.Get("client_id").(string),
ClientSecret: d.Get("client_secret").(string),
TenantID: d.Get("tenant_id").(string),
Environment: d.Get("environment").(string),
SkipProviderRegistration: d.Get("skip_provider_registration").(bool),
}
if err := config.validate(); err != nil {
return nil, err
}
client, err := config.getArmClient()
if err != nil {
return nil, err
}
client.StopContext = p.StopContext()
// replaces the context between tests
p.MetaReset = func() error {
client.StopContext = p.StopContext()
return nil
}
// List all the available providers and their registration state to avoid unnecessary
// requests. This also lets us check if the provider credentials are correct.
providerList, err := client.providers.List(nil, "")
if err != nil {
return nil, fmt.Errorf("Unable to list provider registration status, it is possible that this is due to invalid "+
"credentials or the service principal does not have permission to use the Resource Manager API, Azure "+
"error: %s", err)
}
if !config.SkipProviderRegistration {
err = registerAzureResourceProvidersWithSubscription(*providerList.Value, client.providers)
if err != nil {
return nil, err
}
}
return client, nil
}
}
func registerProviderWithSubscription(providerName string, client resources.ProvidersClient) error {
_, err := client.Register(providerName)
if err != nil {
return fmt.Errorf("Cannot register provider %s with Azure Resource Manager: %s.", providerName, err)
}
return nil
}
var providerRegistrationOnce sync.Once
// registerAzureResourceProvidersWithSubscription uses the providers client to register
// all Azure resource providers which the Terraform provider may require (regardless of
// whether they are actually used by the configuration or not). It was confirmed by Microsoft
// that this is the approach their own internal tools also take.
func | (providerList []resources.Provider, client resources.ProvidersClient) error {
var err error
providerRegistrationOnce.Do(func() {
providers := map[string]struct{}{
"Microsoft.Compute": struct{}{},
"Microsoft.Cache": struct{}{},
"Microsoft.ContainerRegistry": struct{}{},
"Microsoft.ContainerService": struct{}{},
"Microsoft.Network": struct{}{},
"Microsoft.Cdn": struct{}{},
"Microsoft.Storage": struct{}{},
"Microsoft.Sql": struct{}{},
"Microsoft.Search": struct{}{},
"Microsoft.Resources": struct{}{},
"Microsoft.ServiceBus": struct{}{},
"Microsoft.KeyVault": struct{}{},
"Microsoft.EventHub": struct{}{},
}
// filter out any providers already registered
for _, p := range providerList {
if _, ok := providers[*p.Namespace]; !ok {
continue
}
if strings.ToLower(*p.RegistrationState) == "registered" {
log.Printf("[DEBUG] | registerAzureResourceProvidersWithSubscription | identifier_name |
provider.go | : true,
DefaultFunc: schema.EnvDefaultFunc("ARM_ENVIRONMENT", "public"),
},
"skip_provider_registration": {
Type: schema.TypeBool,
Optional: true,
DefaultFunc: schema.EnvDefaultFunc("ARM_SKIP_PROVIDER_REGISTRATION", false),
},
},
DataSourcesMap: map[string]*schema.Resource{
"azurerm_client_config": dataSourceArmClientConfig(),
},
ResourcesMap: map[string]*schema.Resource{
// These resources use the Azure ARM SDK
"azurerm_availability_set": resourceArmAvailabilitySet(),
"azurerm_cdn_endpoint": resourceArmCdnEndpoint(),
"azurerm_cdn_profile": resourceArmCdnProfile(),
"azurerm_container_registry": resourceArmContainerRegistry(),
"azurerm_container_service": resourceArmContainerService(),
"azurerm_eventhub": resourceArmEventHub(),
"azurerm_eventhub_authorization_rule": resourceArmEventHubAuthorizationRule(),
"azurerm_eventhub_consumer_group": resourceArmEventHubConsumerGroup(),
"azurerm_eventhub_namespace": resourceArmEventHubNamespace(),
"azurerm_lb": resourceArmLoadBalancer(),
"azurerm_lb_backend_address_pool": resourceArmLoadBalancerBackendAddressPool(),
"azurerm_lb_nat_rule": resourceArmLoadBalancerNatRule(),
"azurerm_lb_nat_pool": resourceArmLoadBalancerNatPool(),
"azurerm_lb_probe": resourceArmLoadBalancerProbe(),
"azurerm_lb_rule": resourceArmLoadBalancerRule(),
"azurerm_managed_disk": resourceArmManagedDisk(),
"azurerm_key_vault": resourceArmKeyVault(),
"azurerm_local_network_gateway": resourceArmLocalNetworkGateway(),
"azurerm_network_interface": resourceArmNetworkInterface(),
"azurerm_network_security_group": resourceArmNetworkSecurityGroup(),
"azurerm_network_security_rule": resourceArmNetworkSecurityRule(),
"azurerm_public_ip": resourceArmPublicIp(),
"azurerm_redis_cache": resourceArmRedisCache(),
"azurerm_route": resourceArmRoute(),
"azurerm_route_table": resourceArmRouteTable(),
"azurerm_servicebus_namespace": resourceArmServiceBusNamespace(),
"azurerm_servicebus_subscription": resourceArmServiceBusSubscription(),
"azurerm_servicebus_topic": resourceArmServiceBusTopic(),
"azurerm_storage_account": resourceArmStorageAccount(),
"azurerm_storage_blob": resourceArmStorageBlob(),
"azurerm_storage_container": resourceArmStorageContainer(),
"azurerm_storage_share": resourceArmStorageShare(),
"azurerm_storage_queue": resourceArmStorageQueue(),
"azurerm_storage_table": resourceArmStorageTable(),
"azurerm_subnet": resourceArmSubnet(),
"azurerm_template_deployment": resourceArmTemplateDeployment(),
"azurerm_traffic_manager_endpoint": resourceArmTrafficManagerEndpoint(),
"azurerm_traffic_manager_profile": resourceArmTrafficManagerProfile(),
"azurerm_virtual_machine_extension": resourceArmVirtualMachineExtensions(),
"azurerm_virtual_machine": resourceArmVirtualMachine(),
"azurerm_virtual_machine_scale_set": resourceArmVirtualMachineScaleSet(),
"azurerm_virtual_network": resourceArmVirtualNetwork(),
"azurerm_virtual_network_peering": resourceArmVirtualNetworkPeering(),
// These resources use the Riviera SDK
"azurerm_dns_a_record": resourceArmDnsARecord(),
"azurerm_dns_aaaa_record": resourceArmDnsAAAARecord(),
"azurerm_dns_cname_record": resourceArmDnsCNameRecord(),
"azurerm_dns_mx_record": resourceArmDnsMxRecord(),
"azurerm_dns_ns_record": resourceArmDnsNsRecord(),
"azurerm_dns_srv_record": resourceArmDnsSrvRecord(),
"azurerm_dns_txt_record": resourceArmDnsTxtRecord(),
"azurerm_dns_zone": resourceArmDnsZone(),
"azurerm_resource_group": resourceArmResourceGroup(),
"azurerm_search_service": resourceArmSearchService(),
"azurerm_sql_database": resourceArmSqlDatabase(),
"azurerm_sql_firewall_rule": resourceArmSqlFirewallRule(),
"azurerm_sql_server": resourceArmSqlServer(),
},
}
p.ConfigureFunc = providerConfigure(p)
return p
}
// Config is the configuration structure used to instantiate a
// new Azure management client.
type Config struct {
ManagementURL string
SubscriptionID string
ClientID string
ClientSecret string
TenantID string
Environment string
SkipProviderRegistration bool
validateCredentialsOnce sync.Once
}
func (c *Config) validate() error {
var err *multierror.Error
if c.SubscriptionID == "" {
err = multierror.Append(err, fmt.Errorf("Subscription ID must be configured for the AzureRM provider"))
}
if c.ClientID == "" {
err = multierror.Append(err, fmt.Errorf("Client ID must be configured for the AzureRM provider"))
}
if c.ClientSecret == "" {
err = multierror.Append(err, fmt.Errorf("Client Secret must be configured for the AzureRM provider"))
}
if c.TenantID == "" {
err = multierror.Append(err, fmt.Errorf("Tenant ID must be configured for the AzureRM provider"))
}
if c.Environment == "" {
err = multierror.Append(err, fmt.Errorf("Environment must be configured for the AzureRM provider"))
}
return err.ErrorOrNil()
}
func providerConfigure(p *schema.Provider) schema.ConfigureFunc {
return func(d *schema.ResourceData) (interface{}, error) {
config := &Config{
SubscriptionID: d.Get("subscription_id").(string),
ClientID: d.Get("client_id").(string),
ClientSecret: d.Get("client_secret").(string),
TenantID: d.Get("tenant_id").(string),
Environment: d.Get("environment").(string),
SkipProviderRegistration: d.Get("skip_provider_registration").(bool),
}
if err := config.validate(); err != nil {
return nil, err
}
client, err := config.getArmClient()
if err != nil |
client.StopContext = p.StopContext()
// replaces the context between tests
p.MetaReset = func() error {
client.StopContext = p.StopContext()
return nil
}
// List all the available providers and their registration state to avoid unnecessary
// requests. This also lets us check if the provider credentials are correct.
providerList, err := client.providers.List(nil, "")
if err != nil {
return nil, fmt.Errorf("Unable to list provider registration status, it is possible that this is due to invalid "+
"credentials or the service principal does not have permission to use the Resource Manager API, Azure "+
"error: %s", err)
}
if !config.SkipProviderRegistration {
err = registerAzureResourceProvidersWithSubscription(*providerList.Value, client.providers)
if err != nil {
return nil, err
}
}
return client, nil
}
}
func registerProviderWithSubscription(providerName string, client resources.ProvidersClient) error {
_, err := client.Register(providerName)
if err != nil {
return fmt.Errorf("Cannot register provider %s with Azure Resource Manager: %s.", providerName, err)
}
return nil
}
var providerRegistrationOnce sync.Once
// registerAzureResourceProvidersWithSubscription uses the providers client to register
// all Azure resource providers which the Terraform provider may require (regardless of
// whether they are actually used by the configuration or not). It was confirmed by Microsoft
// that this is the approach their own internal tools also take.
func registerAzureResourceProvidersWithSubscription(providerList []resources.Provider, client resources.ProvidersClient) error {
var err error
providerRegistrationOnce.Do(func() {
providers := map[string]struct{}{
"Microsoft.Compute": struct{}{},
"Microsoft.Cache": struct{}{},
"Microsoft.ContainerRegistry": struct{}{},
"Microsoft.ContainerService": struct{}{},
"Microsoft.Network": struct{}{},
"Microsoft.Cdn": struct{}{},
"Microsoft.Storage": struct{}{},
"Microsoft.Sql": struct{}{},
"Microsoft.Search": struct{}{},
"Microsoft.Resources": struct{}{},
"Microsoft.ServiceBus": struct{}{},
"Microsoft.KeyVault": struct{}{},
"Microsoft.EventHub": struct{}{},
}
// filter out any providers already registered
for _, p := range providerList {
if _, ok := providers[*p.Namespace]; !ok {
continue
}
if strings.ToLower(*p.RegistrationState) == "registered" {
log.Printf("[DEBUG | {
return nil, err
} | conditional_block |
saver.go | time.Time // Time the connection was initiated.
Sequence int // Typically zero, but increments for long running connections.
Expiration time.Time // Time we will swap files and increment Sequence.
Writer io.WriteCloser
}
func newConnection(info *inetdiag.InetDiagMsg, timestamp time.Time) *Connection {
conn := Connection{Inode: info.IDiagInode, ID: info.ID.GetSockID(), UID: info.IDiagUID, Slice: "", StartTime: timestamp, Sequence: 0,
Expiration: time.Now()}
return &conn
}
// Rotate opens the next writer for a connection.
// Note that long running connections will have data in multiple directories,
// because, for all segments after the first one, we choose the directory
// based on the time Rotate() was called, and not on the StartTime of the
// connection. Long-running connections with data on multiple days will
// therefore likely have data in multiple date directories.
// (This behavior is new as of April 2020. Prior to then, all files were
// placed in the directory corresponding to the StartTime.)
func (conn *Connection) Rotate(Host string, Pod string, FileAgeLimit time.Duration) error {
datePath := conn.StartTime.Format("2006/01/02")
// For first block, date directory is based on the connection start time.
// For all other blocks, (sequence > 0) it is based on the current time.
if conn.Sequence > 0 {
now := time.Now().UTC()
datePath = now.Format("2006/01/02")
}
err := os.MkdirAll(datePath, 0777)
if err != nil {
return err
}
id := uuid.FromCookie(conn.ID.CookieUint64())
conn.Writer, err = zstd.NewWriter(fmt.Sprintf("%s/%s.%05d.jsonl.zst", datePath, id, conn.Sequence))
if err != nil {
return err
}
conn.writeHeader()
metrics.NewFileCount.Inc()
conn.Expiration = conn.Expiration.Add(10 * time.Minute)
conn.Sequence++
return nil
}
func (conn *Connection) writeHeader() {
msg := netlink.ArchivalRecord{
Metadata: &netlink.Metadata{
UUID: uuid.FromCookie(conn.ID.CookieUint64()),
Sequence: conn.Sequence,
StartTime: conn.StartTime,
},
}
// FIXME: Error handling
bytes, _ := json.Marshal(msg)
conn.Writer.Write(bytes)
conn.Writer.Write([]byte("\n"))
}
type stats struct {
TotalCount int64
NewCount int64
DiffCount int64
ExpiredCount int64
}
func (s *stats) IncTotalCount() {
atomic.AddInt64(&s.TotalCount, 1)
}
func (s *stats) IncNewCount() {
atomic.AddInt64(&s.NewCount, 1)
}
func (s *stats) IncDiffCount() {
atomic.AddInt64(&s.DiffCount, 1)
}
func (s *stats) IncExpiredCount() {
atomic.AddInt64(&s.ExpiredCount, 1)
}
func (s *stats) Copy() stats {
result := stats{}
result.TotalCount = atomic.LoadInt64(&s.TotalCount)
result.NewCount = atomic.LoadInt64(&s.NewCount)
result.DiffCount = atomic.LoadInt64(&s.DiffCount)
result.ExpiredCount = atomic.LoadInt64(&s.ExpiredCount)
return result
}
// TcpStats is used to save the connection stats as connection is closing.
type TcpStats struct {
Sent uint64 // BytesSent
Received uint64 // BytesReceived
}
// Saver provides functionality for saving tcpinfo diffs to connection files.
// It handles arbitrary connections, and only writes to file when the
// significant fields change. (TODO - what does "significant fields" mean). | MarshalChans []MarshalChan
Done *sync.WaitGroup // All marshallers will call Done on this.
Connections map[uint64]*Connection
ClosingStats map[uint64]TcpStats // BytesReceived and BytesSent for connections that are closing.
ClosingTotals TcpStats
cache *cache.Cache
stats stats
eventServer eventsocket.Server
exclude *netlink.ExcludeConfig
}
// NewSaver creates a new Saver for the given host and pod. numMarshaller controls
// how many marshalling goroutines are used to distribute the marshalling workload.
func NewSaver(host string, pod string, numMarshaller int, srv eventsocket.Server, anon anonymize.IPAnonymizer, ex *netlink.ExcludeConfig) *Saver {
m := make([]MarshalChan, 0, numMarshaller)
c := cache.NewCache()
// We start with capacity of 500. This will be reallocated as needed, but this
// is not a performance concern.
conn := make(map[uint64]*Connection, 500)
wg := &sync.WaitGroup{}
wg.Add(1)
ageLim := 10 * time.Minute
for i := 0; i < numMarshaller; i++ {
m = append(m, newMarshaller(wg, anon))
}
return &Saver{
Host: host,
Pod: pod,
FileAgeLimit: ageLim,
MarshalChans: m,
Done: wg,
Connections: conn,
ClosingStats: make(map[uint64]TcpStats, 100),
cache: c,
eventServer: srv,
exclude: ex,
}
}
// queue queues a single ArchivalRecord to the appropriate marshalling queue, based on the
// connection Cookie.
func (svr *Saver) queue(msg *netlink.ArchivalRecord) error {
idm, err := msg.RawIDM.Parse()
if err != nil {
log.Println(err)
// TODO error metric
}
cookie := idm.ID.Cookie()
if cookie == 0 {
return errors.New("Cookie = 0")
}
if len(svr.MarshalChans) < 1 {
return ErrNoMarshallers
}
q := svr.MarshalChans[int(cookie%uint64(len(svr.MarshalChans)))]
conn, ok := svr.Connections[cookie]
if !ok {
// Create a new connection for first time cookies. For late connections already
// terminating, log some info for debugging purposes.
if idm.IDiagState >= uint8(tcp.FIN_WAIT1) {
s, r := msg.GetStats()
log.Println("Starting:", msg.Timestamp.Format("15:04:05.000"), cookie, tcp.State(idm.IDiagState), TcpStats{s, r})
}
conn = newConnection(idm, msg.Timestamp)
svr.eventServer.FlowCreated(msg.Timestamp, uuid.FromCookie(cookie), idm.ID.GetSockID())
svr.Connections[cookie] = conn
} else {
//log.Println("Diff inode:", inode)
}
if time.Now().After(conn.Expiration) && conn.Writer != nil {
q <- Task{nil, conn.Writer} // Close the previous file.
conn.Writer = nil
}
if conn.Writer == nil {
err := conn.Rotate(svr.Host, svr.Pod, svr.FileAgeLimit)
if err != nil {
return err
}
}
q <- Task{msg, conn.Writer}
return nil
}
func (svr *Saver) endConn(cookie uint64) {
svr.eventServer.FlowDeleted(time.Now(), uuid.FromCookie(cookie))
q := svr.MarshalChans[cookie%uint64(len(svr.MarshalChans))]
conn, ok := svr.Connections[cookie]
if ok && conn.Writer != nil {
q <- Task{nil, conn.Writer}
delete(svr.Connections, cookie)
}
}
// Handle a bundle of messages.
// Returns the bytes sent and received on all non-local connections.
func (svr *Saver) handleType(t time.Time, msgs []*netlink.NetlinkMessage) (uint64, uint64) {
var liveSent, liveReceived uint64
for _, msg := range msgs {
// In swap and queue, we want to track the total speed of all connections
// every second.
if msg == nil {
log.Println("Nil message")
continue
}
ar, err := netlink.MakeArchivalRecord(msg, svr.exclude)
if ar == nil {
if err != nil {
log.Println(err)
}
continue
}
ar.Timestamp = t
// Note: If GetStats shows up in profiling, might want to move to once/second code.
s, r := ar.GetStats()
liveSent += s
liveReceived += r
svr.swapAndQueue(ar)
}
return liveSent, liveReceived
}
// MessageSaverLoop runs a loop to receive batches of ArchivalRecords. Local connections
func (svr *Saver) MessageSaverLoop(reader | // TODO - just export an interface, instead of the implementation.
type Saver struct {
Host string // mlabN
Pod string // 3 alpha + 2 decimal
FileAgeLimit time.Duration | random_line_split |
saver.go | .Time // Time the connection was initiated.
Sequence int // Typically zero, but increments for long running connections.
Expiration time.Time // Time we will swap files and increment Sequence.
Writer io.WriteCloser
}
func newConnection(info *inetdiag.InetDiagMsg, timestamp time.Time) *Connection |
// Rotate opens the next writer for a connection.
// Note that long running connections will have data in multiple directories,
// because, for all segments after the first one, we choose the directory
// based on the time Rotate() was called, and not on the StartTime of the
// connection. Long-running connections with data on multiple days will
// therefore likely have data in multiple date directories.
// (This behavior is new as of April 2020. Prior to then, all files were
// placed in the directory corresponding to the StartTime.)
func (conn *Connection) Rotate(Host string, Pod string, FileAgeLimit time.Duration) error {
datePath := conn.StartTime.Format("2006/01/02")
// For first block, date directory is based on the connection start time.
// For all other blocks, (sequence > 0) it is based on the current time.
if conn.Sequence > 0 {
now := time.Now().UTC()
datePath = now.Format("2006/01/02")
}
err := os.MkdirAll(datePath, 0777)
if err != nil {
return err
}
id := uuid.FromCookie(conn.ID.CookieUint64())
conn.Writer, err = zstd.NewWriter(fmt.Sprintf("%s/%s.%05d.jsonl.zst", datePath, id, conn.Sequence))
if err != nil {
return err
}
conn.writeHeader()
metrics.NewFileCount.Inc()
conn.Expiration = conn.Expiration.Add(10 * time.Minute)
conn.Sequence++
return nil
}
func (conn *Connection) writeHeader() {
msg := netlink.ArchivalRecord{
Metadata: &netlink.Metadata{
UUID: uuid.FromCookie(conn.ID.CookieUint64()),
Sequence: conn.Sequence,
StartTime: conn.StartTime,
},
}
// FIXME: Error handling
bytes, _ := json.Marshal(msg)
conn.Writer.Write(bytes)
conn.Writer.Write([]byte("\n"))
}
type stats struct {
TotalCount int64
NewCount int64
DiffCount int64
ExpiredCount int64
}
func (s *stats) IncTotalCount() {
atomic.AddInt64(&s.TotalCount, 1)
}
func (s *stats) IncNewCount() {
atomic.AddInt64(&s.NewCount, 1)
}
func (s *stats) IncDiffCount() {
atomic.AddInt64(&s.DiffCount, 1)
}
func (s *stats) IncExpiredCount() {
atomic.AddInt64(&s.ExpiredCount, 1)
}
func (s *stats) Copy() stats {
result := stats{}
result.TotalCount = atomic.LoadInt64(&s.TotalCount)
result.NewCount = atomic.LoadInt64(&s.NewCount)
result.DiffCount = atomic.LoadInt64(&s.DiffCount)
result.ExpiredCount = atomic.LoadInt64(&s.ExpiredCount)
return result
}
// TcpStats is used to save the connection stats as connection is closing.
type TcpStats struct {
Sent uint64 // BytesSent
Received uint64 // BytesReceived
}
// Saver provides functionality for saving tcpinfo diffs to connection files.
// It handles arbitrary connections, and only writes to file when the
// significant fields change. (TODO - what does "significant fields" mean).
// TODO - just export an interface, instead of the implementation.
type Saver struct {
Host string // mlabN
Pod string // 3 alpha + 2 decimal
FileAgeLimit time.Duration
MarshalChans []MarshalChan
Done *sync.WaitGroup // All marshallers will call Done on this.
Connections map[uint64]*Connection
ClosingStats map[uint64]TcpStats // BytesReceived and BytesSent for connections that are closing.
ClosingTotals TcpStats
cache *cache.Cache
stats stats
eventServer eventsocket.Server
exclude *netlink.ExcludeConfig
}
// NewSaver creates a new Saver for the given host and pod. numMarshaller controls
// how many marshalling goroutines are used to distribute the marshalling workload.
func NewSaver(host string, pod string, numMarshaller int, srv eventsocket.Server, anon anonymize.IPAnonymizer, ex *netlink.ExcludeConfig) *Saver {
m := make([]MarshalChan, 0, numMarshaller)
c := cache.NewCache()
// We start with capacity of 500. This will be reallocated as needed, but this
// is not a performance concern.
conn := make(map[uint64]*Connection, 500)
wg := &sync.WaitGroup{}
wg.Add(1)
ageLim := 10 * time.Minute
for i := 0; i < numMarshaller; i++ {
m = append(m, newMarshaller(wg, anon))
}
return &Saver{
Host: host,
Pod: pod,
FileAgeLimit: ageLim,
MarshalChans: m,
Done: wg,
Connections: conn,
ClosingStats: make(map[uint64]TcpStats, 100),
cache: c,
eventServer: srv,
exclude: ex,
}
}
// queue queues a single ArchivalRecord to the appropriate marshalling queue, based on the
// connection Cookie.
func (svr *Saver) queue(msg *netlink.ArchivalRecord) error {
idm, err := msg.RawIDM.Parse()
if err != nil {
log.Println(err)
// TODO error metric
}
cookie := idm.ID.Cookie()
if cookie == 0 {
return errors.New("Cookie = 0")
}
if len(svr.MarshalChans) < 1 {
return ErrNoMarshallers
}
q := svr.MarshalChans[int(cookie%uint64(len(svr.MarshalChans)))]
conn, ok := svr.Connections[cookie]
if !ok {
// Create a new connection for first time cookies. For late connections already
// terminating, log some info for debugging purposes.
if idm.IDiagState >= uint8(tcp.FIN_WAIT1) {
s, r := msg.GetStats()
log.Println("Starting:", msg.Timestamp.Format("15:04:05.000"), cookie, tcp.State(idm.IDiagState), TcpStats{s, r})
}
conn = newConnection(idm, msg.Timestamp)
svr.eventServer.FlowCreated(msg.Timestamp, uuid.FromCookie(cookie), idm.ID.GetSockID())
svr.Connections[cookie] = conn
} else {
//log.Println("Diff inode:", inode)
}
if time.Now().After(conn.Expiration) && conn.Writer != nil {
q <- Task{nil, conn.Writer} // Close the previous file.
conn.Writer = nil
}
if conn.Writer == nil {
err := conn.Rotate(svr.Host, svr.Pod, svr.FileAgeLimit)
if err != nil {
return err
}
}
q <- Task{msg, conn.Writer}
return nil
}
func (svr *Saver) endConn(cookie uint64) {
svr.eventServer.FlowDeleted(time.Now(), uuid.FromCookie(cookie))
q := svr.MarshalChans[cookie%uint64(len(svr.MarshalChans))]
conn, ok := svr.Connections[cookie]
if ok && conn.Writer != nil {
q <- Task{nil, conn.Writer}
delete(svr.Connections, cookie)
}
}
// Handle a bundle of messages.
// Returns the bytes sent and received on all non-local connections.
func (svr *Saver) handleType(t time.Time, msgs []*netlink.NetlinkMessage) (uint64, uint64) {
var liveSent, liveReceived uint64
for _, msg := range msgs {
// In swap and queue, we want to track the total speed of all connections
// every second.
if msg == nil {
log.Println("Nil message")
continue
}
ar, err := netlink.MakeArchivalRecord(msg, svr.exclude)
if ar == nil {
if err != nil {
log.Println(err)
}
continue
}
ar.Timestamp = t
// Note: If GetStats shows up in profiling, might want to move to once/second code.
s, r := ar.GetStats()
liveSent += s
liveReceived += r
svr.swapAndQueue(ar)
}
return liveSent, liveReceived
}
// MessageSaverLoop runs a loop to receive batches of ArchivalRecords. Local connections
func (svr *Saver) MessageSaver | {
conn := Connection{Inode: info.IDiagInode, ID: info.ID.GetSockID(), UID: info.IDiagUID, Slice: "", StartTime: timestamp, Sequence: 0,
Expiration: time.Now()}
return &conn
} | identifier_body |
saver.go | .StartTime,
},
}
// FIXME: Error handling
bytes, _ := json.Marshal(msg)
conn.Writer.Write(bytes)
conn.Writer.Write([]byte("\n"))
}
type stats struct {
TotalCount int64
NewCount int64
DiffCount int64
ExpiredCount int64
}
func (s *stats) IncTotalCount() {
atomic.AddInt64(&s.TotalCount, 1)
}
func (s *stats) IncNewCount() {
atomic.AddInt64(&s.NewCount, 1)
}
func (s *stats) IncDiffCount() {
atomic.AddInt64(&s.DiffCount, 1)
}
func (s *stats) IncExpiredCount() {
atomic.AddInt64(&s.ExpiredCount, 1)
}
func (s *stats) Copy() stats {
result := stats{}
result.TotalCount = atomic.LoadInt64(&s.TotalCount)
result.NewCount = atomic.LoadInt64(&s.NewCount)
result.DiffCount = atomic.LoadInt64(&s.DiffCount)
result.ExpiredCount = atomic.LoadInt64(&s.ExpiredCount)
return result
}
// TcpStats is used to save the connection stats as connection is closing.
type TcpStats struct {
Sent uint64 // BytesSent
Received uint64 // BytesReceived
}
// Saver provides functionality for saving tcpinfo diffs to connection files.
// It handles arbitrary connections, and only writes to file when the
// significant fields change. (TODO - what does "significant fields" mean).
// TODO - just export an interface, instead of the implementation.
type Saver struct {
Host string // mlabN
Pod string // 3 alpha + 2 decimal
FileAgeLimit time.Duration
MarshalChans []MarshalChan
Done *sync.WaitGroup // All marshallers will call Done on this.
Connections map[uint64]*Connection
ClosingStats map[uint64]TcpStats // BytesReceived and BytesSent for connections that are closing.
ClosingTotals TcpStats
cache *cache.Cache
stats stats
eventServer eventsocket.Server
exclude *netlink.ExcludeConfig
}
// NewSaver creates a new Saver for the given host and pod. numMarshaller controls
// how many marshalling goroutines are used to distribute the marshalling workload.
func NewSaver(host string, pod string, numMarshaller int, srv eventsocket.Server, anon anonymize.IPAnonymizer, ex *netlink.ExcludeConfig) *Saver {
m := make([]MarshalChan, 0, numMarshaller)
c := cache.NewCache()
// We start with capacity of 500. This will be reallocated as needed, but this
// is not a performance concern.
conn := make(map[uint64]*Connection, 500)
wg := &sync.WaitGroup{}
wg.Add(1)
ageLim := 10 * time.Minute
for i := 0; i < numMarshaller; i++ {
m = append(m, newMarshaller(wg, anon))
}
return &Saver{
Host: host,
Pod: pod,
FileAgeLimit: ageLim,
MarshalChans: m,
Done: wg,
Connections: conn,
ClosingStats: make(map[uint64]TcpStats, 100),
cache: c,
eventServer: srv,
exclude: ex,
}
}
// queue queues a single ArchivalRecord to the appropriate marshalling queue, based on the
// connection Cookie.
func (svr *Saver) queue(msg *netlink.ArchivalRecord) error {
idm, err := msg.RawIDM.Parse()
if err != nil {
log.Println(err)
// TODO error metric
}
cookie := idm.ID.Cookie()
if cookie == 0 {
return errors.New("Cookie = 0")
}
if len(svr.MarshalChans) < 1 {
return ErrNoMarshallers
}
q := svr.MarshalChans[int(cookie%uint64(len(svr.MarshalChans)))]
conn, ok := svr.Connections[cookie]
if !ok {
// Create a new connection for first time cookies. For late connections already
// terminating, log some info for debugging purposes.
if idm.IDiagState >= uint8(tcp.FIN_WAIT1) {
s, r := msg.GetStats()
log.Println("Starting:", msg.Timestamp.Format("15:04:05.000"), cookie, tcp.State(idm.IDiagState), TcpStats{s, r})
}
conn = newConnection(idm, msg.Timestamp)
svr.eventServer.FlowCreated(msg.Timestamp, uuid.FromCookie(cookie), idm.ID.GetSockID())
svr.Connections[cookie] = conn
} else {
//log.Println("Diff inode:", inode)
}
if time.Now().After(conn.Expiration) && conn.Writer != nil {
q <- Task{nil, conn.Writer} // Close the previous file.
conn.Writer = nil
}
if conn.Writer == nil {
err := conn.Rotate(svr.Host, svr.Pod, svr.FileAgeLimit)
if err != nil {
return err
}
}
q <- Task{msg, conn.Writer}
return nil
}
func (svr *Saver) endConn(cookie uint64) {
svr.eventServer.FlowDeleted(time.Now(), uuid.FromCookie(cookie))
q := svr.MarshalChans[cookie%uint64(len(svr.MarshalChans))]
conn, ok := svr.Connections[cookie]
if ok && conn.Writer != nil {
q <- Task{nil, conn.Writer}
delete(svr.Connections, cookie)
}
}
// Handle a bundle of messages.
// Returns the bytes sent and received on all non-local connections.
func (svr *Saver) handleType(t time.Time, msgs []*netlink.NetlinkMessage) (uint64, uint64) {
var liveSent, liveReceived uint64
for _, msg := range msgs {
// In swap and queue, we want to track the total speed of all connections
// every second.
if msg == nil {
log.Println("Nil message")
continue
}
ar, err := netlink.MakeArchivalRecord(msg, svr.exclude)
if ar == nil {
if err != nil {
log.Println(err)
}
continue
}
ar.Timestamp = t
// Note: If GetStats shows up in profiling, might want to move to once/second code.
s, r := ar.GetStats()
liveSent += s
liveReceived += r
svr.swapAndQueue(ar)
}
return liveSent, liveReceived
}
// MessageSaverLoop runs a loop to receive batches of ArchivalRecords. Local connections
func (svr *Saver) MessageSaverLoop(readerChannel <-chan netlink.MessageBlock) {
log.Println("Starting Saver")
var reported, closed TcpStats
lastReportTime := time.Time{}.Unix()
closeLogCount := 10000
for msgs := range readerChannel {
// Handle v4 and v6 messages, and return the total bytes sent and received.
// TODO - we only need to collect these stats if this is a reporting cycle.
// NOTE: Prior to April 2020, we were not using UTC here. The servers
// are configured to use UTC time, so this should not make any difference.
s4, r4 := svr.handleType(msgs.V4Time.UTC(), msgs.V4Messages)
s6, r6 := svr.handleType(msgs.V6Time.UTC(), msgs.V6Messages)
// Note that the connections that have closed may have had traffic that
// we never see, and therefore can't account for in metrics.
residual := svr.cache.EndCycle()
// Remove all missing connections from the cache.
// Also keep a metric of the total cumulative send and receive bytes.
for cookie := range residual {
ar := residual[cookie]
var stats TcpStats
var ok bool
if !ar.HasDiagInfo() {
stats, ok = svr.ClosingStats[cookie]
if ok {
// Remove the stats from closing.
svr.ClosingTotals.Sent -= stats.Sent
svr.ClosingTotals.Received -= stats.Received
delete(svr.ClosingStats, cookie)
} else {
log.Println("Missing stats for", cookie)
}
} else {
stats.Sent, stats.Received = ar.GetStats()
}
closed.Sent += stats.Sent
closed.Received += stats.Received
if closeLogCount > 0 | {
idm, err := ar.RawIDM.Parse()
if err != nil {
log.Println("Closed:", ar.Timestamp.Format("15:04:05.000"), cookie, "idm parse error", stats)
} else {
log.Println("Closed:", ar.Timestamp.Format("15:04:05.000"), cookie, tcp.State(idm.IDiagState), stats)
}
closeLogCount--
} | conditional_block | |
saver.go | .Time // Time the connection was initiated.
Sequence int // Typically zero, but increments for long running connections.
Expiration time.Time // Time we will swap files and increment Sequence.
Writer io.WriteCloser
}
func newConnection(info *inetdiag.InetDiagMsg, timestamp time.Time) *Connection {
conn := Connection{Inode: info.IDiagInode, ID: info.ID.GetSockID(), UID: info.IDiagUID, Slice: "", StartTime: timestamp, Sequence: 0,
Expiration: time.Now()}
return &conn
}
// Rotate opens the next writer for a connection.
// Note that long running connections will have data in multiple directories,
// because, for all segments after the first one, we choose the directory
// based on the time Rotate() was called, and not on the StartTime of the
// connection. Long-running connections with data on multiple days will
// therefore likely have data in multiple date directories.
// (This behavior is new as of April 2020. Prior to then, all files were
// placed in the directory corresponding to the StartTime.)
func (conn *Connection) Rotate(Host string, Pod string, FileAgeLimit time.Duration) error {
datePath := conn.StartTime.Format("2006/01/02")
// For first block, date directory is based on the connection start time.
// For all other blocks, (sequence > 0) it is based on the current time.
if conn.Sequence > 0 {
now := time.Now().UTC()
datePath = now.Format("2006/01/02")
}
err := os.MkdirAll(datePath, 0777)
if err != nil {
return err
}
id := uuid.FromCookie(conn.ID.CookieUint64())
conn.Writer, err = zstd.NewWriter(fmt.Sprintf("%s/%s.%05d.jsonl.zst", datePath, id, conn.Sequence))
if err != nil {
return err
}
conn.writeHeader()
metrics.NewFileCount.Inc()
conn.Expiration = conn.Expiration.Add(10 * time.Minute)
conn.Sequence++
return nil
}
func (conn *Connection) writeHeader() {
msg := netlink.ArchivalRecord{
Metadata: &netlink.Metadata{
UUID: uuid.FromCookie(conn.ID.CookieUint64()),
Sequence: conn.Sequence,
StartTime: conn.StartTime,
},
}
// FIXME: Error handling
bytes, _ := json.Marshal(msg)
conn.Writer.Write(bytes)
conn.Writer.Write([]byte("\n"))
}
type stats struct {
TotalCount int64
NewCount int64
DiffCount int64
ExpiredCount int64
}
func (s *stats) IncTotalCount() {
atomic.AddInt64(&s.TotalCount, 1)
}
func (s *stats) IncNewCount() {
atomic.AddInt64(&s.NewCount, 1)
}
func (s *stats) IncDiffCount() {
atomic.AddInt64(&s.DiffCount, 1)
}
func (s *stats) IncExpiredCount() {
atomic.AddInt64(&s.ExpiredCount, 1)
}
func (s *stats) Copy() stats {
result := stats{}
result.TotalCount = atomic.LoadInt64(&s.TotalCount)
result.NewCount = atomic.LoadInt64(&s.NewCount)
result.DiffCount = atomic.LoadInt64(&s.DiffCount)
result.ExpiredCount = atomic.LoadInt64(&s.ExpiredCount)
return result
}
// TcpStats is used to save the connection stats as connection is closing.
type TcpStats struct {
Sent uint64 // BytesSent
Received uint64 // BytesReceived
}
// Saver provides functionality for saving tcpinfo diffs to connection files.
// It handles arbitrary connections, and only writes to file when the
// significant fields change. (TODO - what does "significant fields" mean).
// TODO - just export an interface, instead of the implementation.
type Saver struct {
Host string // mlabN
Pod string // 3 alpha + 2 decimal
FileAgeLimit time.Duration
MarshalChans []MarshalChan
Done *sync.WaitGroup // All marshallers will call Done on this.
Connections map[uint64]*Connection
ClosingStats map[uint64]TcpStats // BytesReceived and BytesSent for connections that are closing.
ClosingTotals TcpStats
cache *cache.Cache
stats stats
eventServer eventsocket.Server
exclude *netlink.ExcludeConfig
}
// NewSaver creates a new Saver for the given host and pod. numMarshaller controls
// how many marshalling goroutines are used to distribute the marshalling workload.
func | (host string, pod string, numMarshaller int, srv eventsocket.Server, anon anonymize.IPAnonymizer, ex *netlink.ExcludeConfig) *Saver {
m := make([]MarshalChan, 0, numMarshaller)
c := cache.NewCache()
// We start with capacity of 500. This will be reallocated as needed, but this
// is not a performance concern.
conn := make(map[uint64]*Connection, 500)
wg := &sync.WaitGroup{}
wg.Add(1)
ageLim := 10 * time.Minute
for i := 0; i < numMarshaller; i++ {
m = append(m, newMarshaller(wg, anon))
}
return &Saver{
Host: host,
Pod: pod,
FileAgeLimit: ageLim,
MarshalChans: m,
Done: wg,
Connections: conn,
ClosingStats: make(map[uint64]TcpStats, 100),
cache: c,
eventServer: srv,
exclude: ex,
}
}
// queue queues a single ArchivalRecord to the appropriate marshalling queue, based on the
// connection Cookie.
func (svr *Saver) queue(msg *netlink.ArchivalRecord) error {
idm, err := msg.RawIDM.Parse()
if err != nil {
log.Println(err)
// TODO error metric
}
cookie := idm.ID.Cookie()
if cookie == 0 {
return errors.New("Cookie = 0")
}
if len(svr.MarshalChans) < 1 {
return ErrNoMarshallers
}
q := svr.MarshalChans[int(cookie%uint64(len(svr.MarshalChans)))]
conn, ok := svr.Connections[cookie]
if !ok {
// Create a new connection for first time cookies. For late connections already
// terminating, log some info for debugging purposes.
if idm.IDiagState >= uint8(tcp.FIN_WAIT1) {
s, r := msg.GetStats()
log.Println("Starting:", msg.Timestamp.Format("15:04:05.000"), cookie, tcp.State(idm.IDiagState), TcpStats{s, r})
}
conn = newConnection(idm, msg.Timestamp)
svr.eventServer.FlowCreated(msg.Timestamp, uuid.FromCookie(cookie), idm.ID.GetSockID())
svr.Connections[cookie] = conn
} else {
//log.Println("Diff inode:", inode)
}
if time.Now().After(conn.Expiration) && conn.Writer != nil {
q <- Task{nil, conn.Writer} // Close the previous file.
conn.Writer = nil
}
if conn.Writer == nil {
err := conn.Rotate(svr.Host, svr.Pod, svr.FileAgeLimit)
if err != nil {
return err
}
}
q <- Task{msg, conn.Writer}
return nil
}
func (svr *Saver) endConn(cookie uint64) {
svr.eventServer.FlowDeleted(time.Now(), uuid.FromCookie(cookie))
q := svr.MarshalChans[cookie%uint64(len(svr.MarshalChans))]
conn, ok := svr.Connections[cookie]
if ok && conn.Writer != nil {
q <- Task{nil, conn.Writer}
delete(svr.Connections, cookie)
}
}
// Handle a bundle of messages.
// Returns the bytes sent and received on all non-local connections.
func (svr *Saver) handleType(t time.Time, msgs []*netlink.NetlinkMessage) (uint64, uint64) {
var liveSent, liveReceived uint64
for _, msg := range msgs {
// In swap and queue, we want to track the total speed of all connections
// every second.
if msg == nil {
log.Println("Nil message")
continue
}
ar, err := netlink.MakeArchivalRecord(msg, svr.exclude)
if ar == nil {
if err != nil {
log.Println(err)
}
continue
}
ar.Timestamp = t
// Note: If GetStats shows up in profiling, might want to move to once/second code.
s, r := ar.GetStats()
liveSent += s
liveReceived += r
svr.swapAndQueue(ar)
}
return liveSent, liveReceived
}
// MessageSaverLoop runs a loop to receive batches of ArchivalRecords. Local connections
func (svr *Saver) MessageSaverLoop | NewSaver | identifier_name |
physical_plan.rs | (&self) -> Arc<Schema>;
/// Specifies how data is partitioned across different nodes in the cluster
fn output_partitioning(&self) -> Partitioning {
Partitioning::UnknownPartitioning(0)
}
/// Specifies the data distribution requirements of all the children for this operator
fn required_child_distribution(&self) -> Distribution {
Distribution::UnspecifiedDistribution
}
/// Specifies how data is ordered in each partition
fn output_ordering(&self) -> Option<Vec<SortOrder>> {
None
}
/// Specifies the data distribution requirements of all the children for this operator
fn required_child_ordering(&self) -> Option<Vec<Vec<SortOrder>>> {
None
}
/// Get the children of this plan. Leaf nodes have no children. Unary nodes have a single
/// child. Binary nodes have two children.
fn children(&self) -> Vec<Arc<PhysicalPlan>> {
vec![]
}
/// Runs this query against one partition returning a stream of columnar batches
async fn execute(
&self,
ctx: Arc<dyn ExecutionContext>,
partition_index: usize,
) -> Result<ColumnarBatchStream>;
}
pub trait Expression: Send + Sync + Debug {
/// Get the data type of this expression, given the schema of the input
fn data_type(&self, input_schema: &Schema) -> Result<DataType>;
/// Decide whether this expression is nullable, given the schema of the input
fn nullable(&self, input_schema: &Schema) -> Result<bool>;
/// Evaluate an expression against a ColumnarBatch to produce a scalar or columnar result.
fn evaluate(&self, input: &ColumnarBatch) -> Result<ColumnarValue>;
}
/// Aggregate expression that can be evaluated against a RecordBatch
pub trait AggregateExpr: Send + Sync + Debug {
/// Get the data type of this expression, given the schema of the input
fn data_type(&self, input_schema: &Schema) -> Result<DataType>;
/// Decide whether this expression is nullable, given the schema of the input
fn nullable(&self, input_schema: &Schema) -> Result<bool>;
/// Evaluate the expression being aggregated
fn evaluate_input(&self, batch: &ColumnarBatch) -> Result<ColumnarValue>;
/// Create an accumulator for this aggregate expression
fn create_accumulator(&self, mode: &AggregateMode) -> Box<dyn Accumulator>;
}
/// Aggregate accumulator
pub trait Accumulator: Send + Sync {
/// Update the accumulator based on a columnar value
fn accumulate(&mut self, value: &ColumnarValue) -> Result<()>;
/// Get the final value for the accumulator
fn get_value(&self) -> Result<Option<ScalarValue>>;
}
/// Action that can be sent to an executor
#[derive(Debug, Clone)]
pub enum Action {
/// Execute the query with DataFusion and return the results
InteractiveQuery {
plan: LogicalPlan,
settings: HashMap<String, String>,
},
/// Execute a query and store the results in memory
Execute(ExecutionTask),
/// Collect a shuffle
FetchShuffle(ShuffleId),
}
pub type MaybeColumnarBatch = Result<Option<ColumnarBatch>>;
/// Batch of columnar data.
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ColumnarBatch {
schema: Arc<Schema>,
columns: HashMap<String, ColumnarValue>,
}
impl ColumnarBatch {
pub fn from_arrow(batch: &RecordBatch) -> Self {
let columns = batch
.columns()
.iter()
.enumerate()
.map(|(i, array)| {
(
batch.schema().field(i).name().clone(),
ColumnarValue::Columnar(array.clone()),
)
})
.collect();
Self {
schema: batch.schema(),
columns,
}
}
pub fn from_values(values: &[ColumnarValue], schema: &Schema) -> Self {
let columns = schema
.fields()
.iter()
.enumerate()
.map(|(i, f)| (f.name().clone(), values[i].clone()))
.collect();
Self {
schema: Arc::new(schema.clone()),
columns,
}
}
pub fn to_arrow(&self) -> Result<RecordBatch> {
let arrays = self
.schema
.fields()
.iter()
.map(|c| {
match self.column(c.name())? {
ColumnarValue::Columnar(array) => Ok(array.clone()),
ColumnarValue::Scalar(_, _) => {
// note that this can be implemented easily if needed
Err(ballista_error("Cannot convert scalar value to Arrow array"))
}
}
})
.collect::<Result<Vec<_>>>()?;
Ok(RecordBatch::try_new(self.schema.clone(), arrays)?)
}
pub fn schema(&self) -> Arc<Schema> {
self.schema.clone()
}
pub fn num_columns(&self) -> usize {
self.columns.len()
}
pub fn num_rows(&self) -> usize {
self.columns[self.schema.field(0).name()].len()
}
pub fn column(&self, name: &str) -> Result<&ColumnarValue> {
Ok(&self.columns[name]) |
pub fn memory_size(&self) -> usize {
self.columns.values().map(|c| c.memory_size()).sum()
}
}
macro_rules! build_literal_array {
($LEN:expr, $BUILDER:ident, $VALUE:expr) => {{
let mut builder = $BUILDER::new($LEN);
for _ in 0..$LEN {
builder.append_value($VALUE)?;
}
Ok(Arc::new(builder.finish()))
}};
}
/// A columnar value can either be a scalar value or an Arrow array.
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub enum ColumnarValue {
Scalar(ScalarValue, usize),
Columnar(ArrayRef),
}
impl ColumnarValue {
pub fn len(&self) -> usize {
match self {
ColumnarValue::Scalar(_, n) => *n,
ColumnarValue::Columnar(array) => array.len(),
}
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn data_type(&self) -> &DataType {
match self {
ColumnarValue::Columnar(array) => array.data_type(),
ColumnarValue::Scalar(value, _) => match value {
ScalarValue::UInt8(_) => &DataType::UInt8,
ScalarValue::UInt16(_) => &DataType::UInt16,
ScalarValue::UInt32(_) => &DataType::UInt32,
ScalarValue::UInt64(_) => &DataType::UInt64,
ScalarValue::Int8(_) => &DataType::Int8,
ScalarValue::Int16(_) => &DataType::Int16,
ScalarValue::Int32(_) => &DataType::Int32,
ScalarValue::Int64(_) => &DataType::Int64,
ScalarValue::Float32(_) => &DataType::Float32,
ScalarValue::Float64(_) => &DataType::Float64,
_ => unimplemented!(),
},
}
}
pub fn to_arrow(&self) -> Result<ArrayRef> {
match self {
ColumnarValue::Columnar(array) => Ok(array.clone()),
ColumnarValue::Scalar(value, n) => match value {
ScalarValue::Int8(value) => build_literal_array!(*n, Int8Builder, *value),
ScalarValue::Int16(value) => build_literal_array!(*n, Int16Builder, *value),
ScalarValue::Int32(value) => build_literal_array!(*n, Int32Builder, *value),
ScalarValue::Int64(value) => build_literal_array!(*n, Int64Builder, *value),
ScalarValue::UInt8(value) => build_literal_array!(*n, UInt8Builder, *value),
ScalarValue::UInt16(value) => build_literal_array!(*n, UInt16Builder, *value),
ScalarValue::UInt32(value) => build_literal_array!(*n, UInt32Builder, *value),
ScalarValue::UInt64(value) => build_literal_array!(*n, UInt64Builder, *value),
ScalarValue::Float32(value) => build_literal_array!(*n, Float32Builder, *value),
ScalarValue::Float64(value) => build_literal_array!(*n, Float64Builder, *value),
ScalarValue::Utf8(value) => build_literal_array!(*n, StringBuilder, value),
other => Err(ballista_error(&format!(
"Unsupported literal type {:?}",
other
))),
},
}
}
pub fn memory_size(&self) -> usize {
//TODO delegate to Arrow once https://issues.apache.org/jira/browse/ARROW-9582 is
// implemented
match self {
ColumnarValue::Columnar(array) => {
let mut size = 0;
for buffer in array.data().buffers() {
size += buffer.capacity();
}
size
}
_ => 0,
}
}
}
/// Enumeration wrapping physical plan structs so that they can be represented in a tree easily
/// and processed using pattern matching
#[derive(Clone)]
pub enum PhysicalPlan {
/// Projection.
Projection(Arc<ProjectionExec>),
/// | } | random_line_split |
physical_plan.rs | _literal_array!(*n, StringBuilder, value),
other => Err(ballista_error(&format!(
"Unsupported literal type {:?}",
other
))),
},
}
}
pub fn memory_size(&self) -> usize {
//TODO delegate to Arrow once https://issues.apache.org/jira/browse/ARROW-9582 is
// implemented
match self {
ColumnarValue::Columnar(array) => {
let mut size = 0;
for buffer in array.data().buffers() {
size += buffer.capacity();
}
size
}
_ => 0,
}
}
}
/// Enumeration wrapping physical plan structs so that they can be represented in a tree easily
/// and processed using pattern matching
#[derive(Clone)]
pub enum PhysicalPlan {
/// Projection.
Projection(Arc<ProjectionExec>),
/// Filter a.k.a predicate.
Filter(Arc<FilterExec>),
/// Hash aggregate
HashAggregate(Arc<HashAggregateExec>),
/// Performs a shuffle that will result in the desired partitioning.
ShuffleExchange(Arc<ShuffleExchangeExec>),
/// Reads results from a ShuffleExchange
ShuffleReader(Arc<ShuffleReaderExec>),
/// Scans a partitioned Parquet data source
ParquetScan(Arc<ParquetScanExec>),
/// Scans a partitioned CSV data source
CsvScan(Arc<CsvScanExec>),
/// Scans an in-memory table
InMemoryTableScan(Arc<InMemoryTableScanExec>),
}
impl PhysicalPlan {
pub fn as_execution_plan(&self) -> Arc<dyn ExecutionPlan> {
match self {
Self::Projection(exec) => exec.clone(),
Self::Filter(exec) => exec.clone(),
Self::HashAggregate(exec) => exec.clone(),
Self::ParquetScan(exec) => exec.clone(),
Self::CsvScan(exec) => exec.clone(),
Self::ShuffleExchange(exec) => exec.clone(),
Self::ShuffleReader(exec) => exec.clone(),
Self::InMemoryTableScan(exec) => exec.clone(),
}
}
pub fn with_new_children(&self, new_children: Vec<Arc<PhysicalPlan>>) -> PhysicalPlan {
match self {
Self::HashAggregate(exec) => {
Self::HashAggregate(Arc::new(exec.with_new_children(new_children)))
}
_ => unimplemented!(),
}
}
fn fmt_with_indent(&self, f: &mut fmt::Formatter, indent: usize) -> fmt::Result {
if indent > 0 {
writeln!(f)?;
for _ in 0..indent {
write!(f, " ")?;
}
}
match self {
PhysicalPlan::CsvScan(exec) => write!(
f,
"CsvScan: {:?}, partitions={}; projection={:?}",
exec.path,
exec.filenames.len(),
exec.projection
),
PhysicalPlan::ParquetScan(exec) => write!(
f,
"ParquetScan: {:?}, partitions={}; projection={:?}",
exec.path,
exec.filenames.len(),
exec.projection
),
PhysicalPlan::HashAggregate(exec) => {
write!(
f,
"HashAggregate: mode={:?}, groupExpr={:?}, aggrExpr={:?}",
exec.mode, exec.group_expr, exec.aggr_expr
)?;
exec.child.fmt_with_indent(f, indent + 1)
}
PhysicalPlan::ShuffleExchange(exec) => {
write!(f, "Shuffle: {:?}", exec.as_ref().output_partitioning())?;
exec.as_ref().child.fmt_with_indent(f, indent + 1)
}
PhysicalPlan::ShuffleReader(exec) => {
write!(f, "ShuffleReader: shuffle_id={:?}", exec.shuffle_id)
}
PhysicalPlan::Projection(_exec) => write!(f, "Projection:"),
PhysicalPlan::Filter(_exec) => write!(f, "Filter:"),
_ => write!(f, "???"),
}
}
}
impl fmt::Debug for PhysicalPlan {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.fmt_with_indent(f, 0)
}
}
#[derive(Debug, Clone)]
pub enum Distribution {
UnspecifiedDistribution,
SinglePartition,
BroadcastDistribution,
ClusteredDistribution {
required_num_partitions: usize,
clustering: Vec<Expr>,
},
HashClusteredDistribution {
required_num_partitions: usize,
clustering: Vec<Expr>,
},
OrderedDistribution(Vec<SortOrder>),
}
#[derive(Debug, Clone)]
pub enum JoinType {
Inner,
}
#[derive(Debug, Clone)]
pub enum BuildSide {
BuildLeft,
BuildRight,
}
#[derive(Debug, Clone)]
pub enum SortDirection {
Ascending,
Descending,
}
/// Aggregate operator modes.
#[derive(Debug, Clone)]
pub enum AggregateMode {
/// Partial aggregation that can run in parallel per partition
Partial,
/// Perform final aggregation on results of partial aggregation. For example, this would
/// produce the SUM of SUMs, or the SUMs of COUNTs.
Final,
/// Perform complete aggregation in one pass. This is used when there is only a single
/// partition to operate on.
Complete,
}
#[derive(Debug, Clone)]
pub struct SortOrder {
child: Arc<Expr>,
direction: SortDirection,
null_ordering: NullOrdering,
}
#[derive(Debug, Clone)]
pub enum NullOrdering {
NullsFirst,
NullsLast,
}
/// Partitioning schemes supported by operators.
#[derive(Debug, Clone)]
pub enum Partitioning {
UnknownPartitioning(usize),
HashPartitioning(usize, Vec<Arc<Expr>>),
}
impl Partitioning {
pub fn partition_count(&self) -> usize {
use Partitioning::*;
match self {
UnknownPartitioning(n) => *n,
HashPartitioning(n, _) => *n,
}
}
}
/// Unique identifier for the output shuffle partition of an operator.
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ShuffleId {
pub(crate) job_uuid: Uuid,
pub(crate) stage_id: usize,
pub(crate) partition_id: usize,
}
impl ShuffleId {
pub fn new(job_uuid: Uuid, stage_id: usize, partition_id: usize) -> Self {
Self {
job_uuid,
stage_id,
partition_id,
}
}
}
pub struct ShuffleLocation {}
/// Translate a logical expression into a physical expression that can be evaluated against
/// input data.
pub fn compile_expression(expr: &Expr, input: &Schema) -> Result<Arc<dyn Expression>> {
match expr {
Expr::Alias(expr, name) => Ok(alias(compile_expression(expr, input)?, name)),
Expr::Column(name) => Ok(col(name)),
Expr::Literal(value) => Ok(lit(value.to_owned())),
Expr::BinaryExpr { left, op, right } => {
let l = compile_expression(left, input)?;
let r = compile_expression(right, input)?;
match op {
Operator::Plus => Ok(add(l, r)),
Operator::Minus => Ok(subtract(l, r)),
Operator::Multiply => Ok(mult(l, r)),
Operator::Divide => Ok(div(l, r)),
Operator::Lt
| Operator::LtEq
| Operator::Gt
| Operator::GtEq
| Operator::Eq
| Operator::NotEq => Ok(compare(l, op, r)),
other => Err(ballista_error(&format!(
"Unsupported binary operator in compile_expression {:?}",
other
))),
}
}
other => Err(ballista_error(&format!(
"Unsupported expression in compile_expression {:?}",
other
))),
}
}
/// Translate one or more logical expressions into physical expressions that can be evaluated
/// against input data.
pub fn compile_expressions(expr: &[Expr], input: &Schema) -> Result<Vec<Arc<dyn Expression>>> {
expr.iter().map(|e| compile_expression(e, input)).collect()
}
/// Translate a logical aggregate expression into a physical expression that can be evaluated
/// against input data.
pub fn compile_aggregate_expression(
expr: &Expr,
input_schema: &Schema,
) -> Result<Arc<dyn AggregateExpr>> {
match expr {
Expr::Alias(expr, alias) => Ok(aliased_aggr(
compile_aggregate_expression(expr, input_schema)?,
alias,
)),
Expr::AggregateFunction { name, args, .. } => match name.to_lowercase().as_ref() {
"avg" => Ok(avg(compile_expression(&args[0], input_schema)?)),
"count" => Ok(count(compile_expression(&args[0], input_schema)?)),
"max" => Ok(max(compile_expression(&args[0], input_schema)?)),
"min" => Ok(min(compile_expression(&args[0], input_schema)?)),
"sum" => Ok(sum(compile_expression(&args[0], input_schema)?)),
other => Err(ballista_error(&format!(
"Unsupported aggregate function in compile_aggregate_expression '{}'",
other
))),
},
other => Err(ballista_error(&format!(
"Unsupported aggregate expression in compile_aggregate_expression {:?}",
other
))),
}
}
/// Translate one or more logical aggregate expressions into physical expressions that can be evaluated
/// against input data.
pub fn | compile_aggregate_expressions | identifier_name | |
transaction.go | once = br.ReadU32LE()
t.SystemFee = int64(br.ReadU64LE())
t.NetworkFee = int64(br.ReadU64LE())
t.ValidUntilBlock = br.ReadU32LE()
nsigners := br.ReadVarUint()
if br.Err != nil {
return
}
if nsigners > MaxAttributes {
br.Err = errors.New("too many signers")
return
} else if nsigners == 0 {
br.Err = errors.New("missing signers")
return
}
t.Signers = make([]Signer, nsigners)
for i := 0; i < int(nsigners); i++ {
t.Signers[i].DecodeBinary(br)
}
nattrs := br.ReadVarUint()
if nattrs > MaxAttributes-nsigners {
br.Err = errors.New("too many attributes")
return
}
t.Attributes = make([]Attribute, nattrs)
for i := 0; i < int(nattrs); i++ {
t.Attributes[i].DecodeBinary(br)
}
t.Script = br.ReadVarBytes(MaxScriptLength)
if br.Err == nil {
br.Err = t.isValid()
}
if buf != nil {
end = len(buf) - br.Len()
t.hash = hash.Sha256(buf[start:end])
t.hashed = true
}
}
func (t *Transaction) decodeBinaryNoSize(br *io.BinReader, buf []byte) {
t.decodeHashableFields(br, buf)
if br.Err != nil {
return
}
nscripts := br.ReadVarUint()
if nscripts > MaxAttributes {
br.Err = errors.New("too many witnesses")
return
} else if int(nscripts) != len(t.Signers) {
br.Err = fmt.Errorf("%w: %d vs %d", ErrInvalidWitnessNum, len(t.Signers), len(t.Scripts))
return
}
t.Scripts = make([]Witness, nscripts)
for i := 0; i < int(nscripts); i++ {
t.Scripts[i].DecodeBinary(br)
}
// Create the hash of the transaction at decode, so we dont need
// to do it anymore.
if br.Err == nil && buf == nil {
br.Err = t.createHash()
}
}
// DecodeBinary implements Serializable interface.
func (t *Transaction) DecodeBinary(br *io.BinReader) {
t.decodeBinaryNoSize(br, nil)
if br.Err == nil {
_ = t.Size()
}
}
// EncodeBinary implements Serializable interface.
func (t *Transaction) EncodeBinary(bw *io.BinWriter) {
t.encodeHashableFields(bw)
bw.WriteVarUint(uint64(len(t.Scripts)))
for i := range t.Scripts {
t.Scripts[i].EncodeBinary(bw)
}
}
// encodeHashableFields encodes the fields that are not used for
// signing the transaction, which are all fields except the scripts.
func (t *Transaction) encodeHashableFields(bw *io.BinWriter) {
if len(t.Script) == 0 {
bw.Err = errors.New("transaction has no script")
return
}
bw.WriteB(byte(t.Version))
bw.WriteU32LE(t.Nonce)
bw.WriteU64LE(uint64(t.SystemFee))
bw.WriteU64LE(uint64(t.NetworkFee))
bw.WriteU32LE(t.ValidUntilBlock)
bw.WriteVarUint(uint64(len(t.Signers)))
for i := range t.Signers {
t.Signers[i].EncodeBinary(bw)
}
bw.WriteVarUint(uint64(len(t.Attributes)))
for i := range t.Attributes {
t.Attributes[i].EncodeBinary(bw)
}
bw.WriteVarBytes(t.Script)
}
// EncodeHashableFields returns serialized transaction's fields which are hashed.
func (t *Transaction) EncodeHashableFields() ([]byte, error) {
bw := io.NewBufBinWriter()
t.encodeHashableFields(bw.BinWriter)
if bw.Err != nil {
return nil, bw.Err
}
return bw.Bytes(), nil
}
// createHash creates the hash of the transaction.
func (t *Transaction) createHash() error {
shaHash := sha256.New()
bw := io.NewBinWriterFromIO(shaHash)
t.encodeHashableFields(bw)
if bw.Err != nil {
return bw.Err
}
shaHash.Sum(t.hash[:0])
t.hashed = true
return nil
}
// DecodeHashableFields decodes a part of transaction which should be hashed.
func (t *Transaction) DecodeHashableFields(buf []byte) error {
r := io.NewBinReaderFromBuf(buf)
t.decodeHashableFields(r, buf)
if r.Err != nil {
return r.Err
}
// Ensure all the data was read.
if r.Len() != 0 {
return errors.New("additional data after the signed part")
}
t.Scripts = make([]Witness, 0)
return nil
}
// Bytes converts the transaction to []byte.
func (t *Transaction) Bytes() []byte {
buf := io.NewBufBinWriter()
t.EncodeBinary(buf.BinWriter)
if buf.Err != nil {
return nil
}
return buf.Bytes()
}
// NewTransactionFromBytes decodes byte array into *Transaction.
func NewTransactionFromBytes(b []byte) (*Transaction, error) {
tx := &Transaction{}
r := io.NewBinReaderFromBuf(b)
tx.decodeBinaryNoSize(r, b)
if r.Err != nil {
return nil, r.Err
}
if r.Len() != 0 {
return nil, errors.New("additional data after the transaction")
}
tx.size = len(b)
return tx, nil
}
// FeePerByte returns NetworkFee of the transaction divided by
// its size.
func (t *Transaction) FeePerByte() int64 {
return t.NetworkFee / int64(t.Size())
}
// Size returns size of the serialized transaction.
func (t *Transaction) Size() int {
if t.size == 0 {
t.size = io.GetVarSize(t)
}
return t.size
}
// Sender returns the sender of the transaction which is always on the first place
// in the transaction's signers list.
func (t *Transaction) Sender() util.Uint160 {
if len(t.Signers) == 0 {
panic("transaction does not have signers")
}
return t.Signers[0].Account
}
// transactionJSON is a wrapper for Transaction and
// used for correct marhalling of transaction.Data.
type transactionJSON struct {
TxID util.Uint256 `json:"hash"`
Size int `json:"size"`
Version uint8 `json:"version"`
Nonce uint32 `json:"nonce"`
Sender string `json:"sender"`
SystemFee int64 `json:"sysfee,string"`
NetworkFee int64 `json:"netfee,string"`
ValidUntilBlock uint32 `json:"validuntilblock"`
Attributes []Attribute `json:"attributes"`
Signers []Signer `json:"signers"`
Script []byte `json:"script"`
Scripts []Witness `json:"witnesses"`
}
// MarshalJSON implements json.Marshaler interface.
func (t *Transaction) MarshalJSON() ([]byte, error) {
tx := transactionJSON{
TxID: t.Hash(),
Size: t.Size(),
Version: t.Version,
Nonce: t.Nonce,
Sender: address.Uint160ToString(t.Sender()),
ValidUntilBlock: t.ValidUntilBlock,
Attributes: t.Attributes,
Signers: t.Signers,
Script: t.Script,
Scripts: t.Scripts,
SystemFee: t.SystemFee,
NetworkFee: t.NetworkFee,
}
return json.Marshal(tx)
}
// UnmarshalJSON implements json.Unmarshaler interface.
func (t *Transaction) UnmarshalJSON(data []byte) error {
tx := new(transactionJSON)
if err := json.Unmarshal(data, tx); err != nil {
return err
}
t.Version = tx.Version
t.Nonce = tx.Nonce
t.ValidUntilBlock = tx.ValidUntilBlock
t.Attributes = tx.Attributes
t.Signers = tx.Signers
t.Scripts = tx.Scripts
t.SystemFee = tx.SystemFee
t.NetworkFee = tx.NetworkFee
t.Script = tx.Script
if t.Hash() != tx.TxID {
return errors.New("txid doesn't match transaction hash")
}
if t.Size() != tx.Size {
return errors.New("'size' doesn't match transaction size")
}
return t.isValid()
}
// Various errors for transaction validation.
var (
ErrInvalidVersion = errors.New("only version 0 is supported")
ErrNegativeSystemFee = errors.New("negative system fee")
ErrNegativeNetworkFee = errors.New("negative network fee")
ErrTooBigFees = errors.New("too big fees: int64 overflow")
ErrEmptySigners = errors.New("signers array should contain sender")
ErrNonUniqueSigners = errors.New("transaction signers should be unique")
ErrInvalidAttribute = errors.New("invalid attribute")
ErrEmptyScript = errors.New("no script")
)
// isValid checks whether decoded/unmarshalled transaction has all fields valid.
func (t *Transaction) | isValid | identifier_name | |
transaction.go | VarUint()
if nattrs > MaxAttributes-nsigners {
br.Err = errors.New("too many attributes")
return
}
t.Attributes = make([]Attribute, nattrs)
for i := 0; i < int(nattrs); i++ {
t.Attributes[i].DecodeBinary(br)
}
t.Script = br.ReadVarBytes(MaxScriptLength)
if br.Err == nil {
br.Err = t.isValid()
}
if buf != nil {
end = len(buf) - br.Len()
t.hash = hash.Sha256(buf[start:end])
t.hashed = true
}
}
func (t *Transaction) decodeBinaryNoSize(br *io.BinReader, buf []byte) {
t.decodeHashableFields(br, buf)
if br.Err != nil {
return
}
nscripts := br.ReadVarUint()
if nscripts > MaxAttributes {
br.Err = errors.New("too many witnesses")
return
} else if int(nscripts) != len(t.Signers) {
br.Err = fmt.Errorf("%w: %d vs %d", ErrInvalidWitnessNum, len(t.Signers), len(t.Scripts))
return
}
t.Scripts = make([]Witness, nscripts)
for i := 0; i < int(nscripts); i++ {
t.Scripts[i].DecodeBinary(br)
}
// Create the hash of the transaction at decode, so we dont need
// to do it anymore.
if br.Err == nil && buf == nil {
br.Err = t.createHash()
}
}
// DecodeBinary implements Serializable interface.
func (t *Transaction) DecodeBinary(br *io.BinReader) {
t.decodeBinaryNoSize(br, nil)
if br.Err == nil {
_ = t.Size()
}
}
// EncodeBinary implements Serializable interface.
func (t *Transaction) EncodeBinary(bw *io.BinWriter) {
t.encodeHashableFields(bw)
bw.WriteVarUint(uint64(len(t.Scripts)))
for i := range t.Scripts {
t.Scripts[i].EncodeBinary(bw)
}
}
// encodeHashableFields encodes the fields that are not used for
// signing the transaction, which are all fields except the scripts.
func (t *Transaction) encodeHashableFields(bw *io.BinWriter) {
if len(t.Script) == 0 {
bw.Err = errors.New("transaction has no script")
return
}
bw.WriteB(byte(t.Version))
bw.WriteU32LE(t.Nonce)
bw.WriteU64LE(uint64(t.SystemFee))
bw.WriteU64LE(uint64(t.NetworkFee))
bw.WriteU32LE(t.ValidUntilBlock)
bw.WriteVarUint(uint64(len(t.Signers)))
for i := range t.Signers {
t.Signers[i].EncodeBinary(bw)
}
bw.WriteVarUint(uint64(len(t.Attributes)))
for i := range t.Attributes {
t.Attributes[i].EncodeBinary(bw)
}
bw.WriteVarBytes(t.Script)
}
// EncodeHashableFields returns serialized transaction's fields which are hashed.
func (t *Transaction) EncodeHashableFields() ([]byte, error) {
bw := io.NewBufBinWriter()
t.encodeHashableFields(bw.BinWriter)
if bw.Err != nil {
return nil, bw.Err
}
return bw.Bytes(), nil
}
// createHash creates the hash of the transaction.
func (t *Transaction) createHash() error {
shaHash := sha256.New()
bw := io.NewBinWriterFromIO(shaHash)
t.encodeHashableFields(bw)
if bw.Err != nil {
return bw.Err
}
shaHash.Sum(t.hash[:0])
t.hashed = true
return nil
}
// DecodeHashableFields decodes a part of transaction which should be hashed.
func (t *Transaction) DecodeHashableFields(buf []byte) error {
r := io.NewBinReaderFromBuf(buf)
t.decodeHashableFields(r, buf)
if r.Err != nil {
return r.Err
}
// Ensure all the data was read.
if r.Len() != 0 {
return errors.New("additional data after the signed part")
}
t.Scripts = make([]Witness, 0)
return nil
}
// Bytes converts the transaction to []byte.
func (t *Transaction) Bytes() []byte {
buf := io.NewBufBinWriter()
t.EncodeBinary(buf.BinWriter)
if buf.Err != nil {
return nil
}
return buf.Bytes()
}
// NewTransactionFromBytes decodes byte array into *Transaction.
func NewTransactionFromBytes(b []byte) (*Transaction, error) {
tx := &Transaction{}
r := io.NewBinReaderFromBuf(b)
tx.decodeBinaryNoSize(r, b)
if r.Err != nil {
return nil, r.Err
}
if r.Len() != 0 {
return nil, errors.New("additional data after the transaction")
}
tx.size = len(b)
return tx, nil
}
// FeePerByte returns NetworkFee of the transaction divided by
// its size.
func (t *Transaction) FeePerByte() int64 {
return t.NetworkFee / int64(t.Size())
}
// Size returns size of the serialized transaction.
func (t *Transaction) Size() int {
if t.size == 0 {
t.size = io.GetVarSize(t)
}
return t.size
}
// Sender returns the sender of the transaction which is always on the first place
// in the transaction's signers list.
func (t *Transaction) Sender() util.Uint160 {
if len(t.Signers) == 0 {
panic("transaction does not have signers")
}
return t.Signers[0].Account
}
// transactionJSON is a wrapper for Transaction and
// used for correct marhalling of transaction.Data.
type transactionJSON struct {
TxID util.Uint256 `json:"hash"`
Size int `json:"size"`
Version uint8 `json:"version"`
Nonce uint32 `json:"nonce"`
Sender string `json:"sender"`
SystemFee int64 `json:"sysfee,string"`
NetworkFee int64 `json:"netfee,string"`
ValidUntilBlock uint32 `json:"validuntilblock"`
Attributes []Attribute `json:"attributes"`
Signers []Signer `json:"signers"`
Script []byte `json:"script"`
Scripts []Witness `json:"witnesses"`
}
// MarshalJSON implements json.Marshaler interface.
func (t *Transaction) MarshalJSON() ([]byte, error) {
tx := transactionJSON{
TxID: t.Hash(),
Size: t.Size(),
Version: t.Version,
Nonce: t.Nonce,
Sender: address.Uint160ToString(t.Sender()),
ValidUntilBlock: t.ValidUntilBlock,
Attributes: t.Attributes,
Signers: t.Signers,
Script: t.Script,
Scripts: t.Scripts,
SystemFee: t.SystemFee,
NetworkFee: t.NetworkFee,
}
return json.Marshal(tx)
}
// UnmarshalJSON implements json.Unmarshaler interface.
func (t *Transaction) UnmarshalJSON(data []byte) error {
tx := new(transactionJSON)
if err := json.Unmarshal(data, tx); err != nil {
return err
}
t.Version = tx.Version
t.Nonce = tx.Nonce
t.ValidUntilBlock = tx.ValidUntilBlock
t.Attributes = tx.Attributes
t.Signers = tx.Signers
t.Scripts = tx.Scripts
t.SystemFee = tx.SystemFee
t.NetworkFee = tx.NetworkFee
t.Script = tx.Script
if t.Hash() != tx.TxID {
return errors.New("txid doesn't match transaction hash")
}
if t.Size() != tx.Size {
return errors.New("'size' doesn't match transaction size")
}
return t.isValid()
}
// Various errors for transaction validation.
var (
ErrInvalidVersion = errors.New("only version 0 is supported")
ErrNegativeSystemFee = errors.New("negative system fee")
ErrNegativeNetworkFee = errors.New("negative network fee")
ErrTooBigFees = errors.New("too big fees: int64 overflow")
ErrEmptySigners = errors.New("signers array should contain sender")
ErrNonUniqueSigners = errors.New("transaction signers should be unique")
ErrInvalidAttribute = errors.New("invalid attribute")
ErrEmptyScript = errors.New("no script")
)
// isValid checks whether decoded/unmarshalled transaction has all fields valid.
func (t *Transaction) isValid() error {
if t.Version > 0 && t.Version != DummyVersion {
return ErrInvalidVersion
}
if t.SystemFee < 0 {
return ErrNegativeSystemFee
}
if t.NetworkFee < 0 {
return ErrNegativeNetworkFee
}
if t.NetworkFee+t.SystemFee < t.SystemFee {
return ErrTooBigFees
}
if len(t.Signers) == 0 {
return ErrEmptySigners
}
for i := 0; i < len(t.Signers); i++ {
for j := i + 1; j < len(t.Signers); j++ | {
if t.Signers[i].Account.Equals(t.Signers[j].Account) {
return ErrNonUniqueSigners
}
} | conditional_block | |
transaction.go | Version uint8
// Random number to avoid hash collision.
Nonce uint32
// Fee to be burned.
SystemFee int64
// Fee to be distributed to consensus nodes.
NetworkFee int64
// Maximum blockchain height exceeding which
// transaction should fail verification.
ValidUntilBlock uint32
// Code to run in NeoVM for this transaction.
Script []byte
// Transaction attributes.
Attributes []Attribute
// Transaction signers list (starts with Sender).
Signers []Signer
// The scripts that comes with this transaction.
// Scripts exist out of the verification script
// and invocation script.
Scripts []Witness
// size is transaction's serialized size.
size int
// Hash of the transaction (double SHA256).
hash util.Uint256
// Whether hash is correct.
hashed bool
// Trimmed indicates this is a transaction from trimmed
// data.
Trimmed bool
}
// NewTrimmedTX returns a trimmed transaction with only its hash
// and Trimmed to true.
func NewTrimmedTX(hash util.Uint256) *Transaction {
return &Transaction{
hash: hash,
hashed: true,
Trimmed: true,
}
}
// New returns a new transaction to execute given script and pay given system
// fee.
func New(script []byte, gas int64) *Transaction {
return &Transaction{
Version: 0,
Nonce: rand.Uint32(),
Script: script,
SystemFee: gas,
Attributes: []Attribute{},
Signers: []Signer{},
Scripts: []Witness{},
}
}
// Hash returns the hash of the transaction.
func (t *Transaction) Hash() util.Uint256 {
if !t.hashed {
if t.createHash() != nil {
panic("failed to compute hash!")
}
}
return t.hash
}
// HasAttribute returns true iff t has an attribute of type typ.
func (t *Transaction) HasAttribute(typ AttrType) bool {
for i := range t.Attributes {
if t.Attributes[i].Type == typ {
return true
}
}
return false
}
// GetAttributes returns the list of transaction's attributes of the given type.
// Returns nil in case if attributes not found.
func (t *Transaction) GetAttributes(typ AttrType) []Attribute {
var result []Attribute
for _, attr := range t.Attributes {
if attr.Type == typ {
result = append(result, attr)
}
}
return result
}
// decodeHashableFields decodes the fields that are used for signing the
// transaction, which are all fields except the scripts.
func (t *Transaction) decodeHashableFields(br *io.BinReader, buf []byte) {
var start, end int
if buf != nil {
start = len(buf) - br.Len()
}
t.Version = uint8(br.ReadB())
t.Nonce = br.ReadU32LE()
t.SystemFee = int64(br.ReadU64LE())
t.NetworkFee = int64(br.ReadU64LE())
t.ValidUntilBlock = br.ReadU32LE()
nsigners := br.ReadVarUint()
if br.Err != nil {
return
}
if nsigners > MaxAttributes {
br.Err = errors.New("too many signers")
return
} else if nsigners == 0 {
br.Err = errors.New("missing signers")
return
}
t.Signers = make([]Signer, nsigners)
for i := 0; i < int(nsigners); i++ {
t.Signers[i].DecodeBinary(br)
}
nattrs := br.ReadVarUint()
if nattrs > MaxAttributes-nsigners {
br.Err = errors.New("too many attributes")
return
}
t.Attributes = make([]Attribute, nattrs)
for i := 0; i < int(nattrs); i++ {
t.Attributes[i].DecodeBinary(br)
}
t.Script = br.ReadVarBytes(MaxScriptLength)
if br.Err == nil {
br.Err = t.isValid()
}
if buf != nil {
end = len(buf) - br.Len()
t.hash = hash.Sha256(buf[start:end])
t.hashed = true
}
}
func (t *Transaction) decodeBinaryNoSize(br *io.BinReader, buf []byte) {
t.decodeHashableFields(br, buf)
if br.Err != nil {
return
}
nscripts := br.ReadVarUint()
if nscripts > MaxAttributes {
br.Err = errors.New("too many witnesses")
return
} else if int(nscripts) != len(t.Signers) {
br.Err = fmt.Errorf("%w: %d vs %d", ErrInvalidWitnessNum, len(t.Signers), len(t.Scripts))
return
}
t.Scripts = make([]Witness, nscripts)
for i := 0; i < int(nscripts); i++ {
t.Scripts[i].DecodeBinary(br)
}
// Create the hash of the transaction at decode, so we dont need
// to do it anymore.
if br.Err == nil && buf == nil {
br.Err = t.createHash()
}
}
// DecodeBinary implements Serializable interface.
func (t *Transaction) DecodeBinary(br *io.BinReader) {
t.decodeBinaryNoSize(br, nil)
if br.Err == nil {
_ = t.Size()
}
}
// EncodeBinary implements Serializable interface.
func (t *Transaction) EncodeBinary(bw *io.BinWriter) {
t.encodeHashableFields(bw)
bw.WriteVarUint(uint64(len(t.Scripts)))
for i := range t.Scripts {
t.Scripts[i].EncodeBinary(bw)
}
}
// encodeHashableFields encodes the fields that are not used for
// signing the transaction, which are all fields except the scripts.
func (t *Transaction) encodeHashableFields(bw *io.BinWriter) {
if len(t.Script) == 0 {
bw.Err = errors.New("transaction has no script")
return
}
bw.WriteB(byte(t.Version))
bw.WriteU32LE(t.Nonce)
bw.WriteU64LE(uint64(t.SystemFee))
bw.WriteU64LE(uint64(t.NetworkFee))
bw.WriteU32LE(t.ValidUntilBlock)
bw.WriteVarUint(uint64(len(t.Signers)))
for i := range t.Signers {
t.Signers[i].EncodeBinary(bw)
}
bw.WriteVarUint(uint64(len(t.Attributes)))
for i := range t.Attributes {
t.Attributes[i].EncodeBinary(bw)
}
bw.WriteVarBytes(t.Script)
}
// EncodeHashableFields returns serialized transaction's fields which are hashed.
func (t *Transaction) EncodeHashableFields() ([]byte, error) {
bw := io.NewBufBinWriter()
t.encodeHashableFields(bw.BinWriter)
if bw.Err != nil {
return nil, bw.Err
}
return bw.Bytes(), nil
}
// createHash creates the hash of the transaction.
func (t *Transaction) createHash() error {
shaHash := sha256.New()
bw := io.NewBinWriterFromIO(shaHash)
t.encodeHashableFields(bw)
if bw.Err != nil {
return bw.Err
}
shaHash.Sum(t.hash[:0])
t.hashed = true
return nil
}
// DecodeHashableFields decodes a part of transaction which should be hashed.
func (t *Transaction) DecodeHashableFields(buf []byte) error {
r := io.NewBinReaderFromBuf(buf)
t.decodeHashableFields(r, buf)
if r.Err != nil {
return r.Err
}
// Ensure all the data was read.
if r.Len() != 0 {
return errors.New("additional data after the signed part")
}
t.Scripts = make([]Witness, 0)
return nil
}
// Bytes converts the transaction to []byte.
func (t *Transaction) Bytes() []byte {
buf := io.NewBufBinWriter()
t.EncodeBinary(buf.BinWriter)
if buf.Err != nil {
return nil
}
return buf.Bytes()
}
// NewTransactionFromBytes decodes byte array into *Transaction.
func NewTransactionFromBytes(b []byte) (*Transaction, error) {
tx := &Transaction{}
r := io.NewBinReaderFromBuf(b)
tx.decodeBinaryNoSize(r, b)
if r.Err != nil {
return nil, r.Err
}
if r.Len() != 0 {
return nil, errors.New("additional data after the transaction")
}
tx.size = len(b)
return tx, nil
}
// FeePerByte returns NetworkFee of the transaction divided by
// its size.
func (t *Transaction) FeePerByte() int64 {
return t.NetworkFee / int64(t.Size())
}
// Size returns size of the serialized transaction.
func (t *Transaction) Size() int {
if t.size == 0 {
t.size = io.GetVarSize(t)
}
return t.size
}
// Sender returns the sender of the transaction which is always on the first place
// in the transaction's signers list.
func (t *Transaction) Sender() util.Uint160 {
if len(t.Signers) == 0 {
panic("transaction does not have signers")
}
return t | // The trading version which is currently 0. | random_line_split | |
transaction.go | Attributes []Attribute
// Transaction signers list (starts with Sender).
Signers []Signer
// The scripts that comes with this transaction.
// Scripts exist out of the verification script
// and invocation script.
Scripts []Witness
// size is transaction's serialized size.
size int
// Hash of the transaction (double SHA256).
hash util.Uint256
// Whether hash is correct.
hashed bool
// Trimmed indicates this is a transaction from trimmed
// data.
Trimmed bool
}
// NewTrimmedTX returns a trimmed transaction with only its hash
// and Trimmed to true.
func NewTrimmedTX(hash util.Uint256) *Transaction {
return &Transaction{
hash: hash,
hashed: true,
Trimmed: true,
}
}
// New returns a new transaction to execute given script and pay given system
// fee.
func New(script []byte, gas int64) *Transaction {
return &Transaction{
Version: 0,
Nonce: rand.Uint32(),
Script: script,
SystemFee: gas,
Attributes: []Attribute{},
Signers: []Signer{},
Scripts: []Witness{},
}
}
// Hash returns the hash of the transaction.
func (t *Transaction) Hash() util.Uint256 {
if !t.hashed {
if t.createHash() != nil {
panic("failed to compute hash!")
}
}
return t.hash
}
// HasAttribute returns true iff t has an attribute of type typ.
func (t *Transaction) HasAttribute(typ AttrType) bool |
// GetAttributes returns the list of transaction's attributes of the given type.
// Returns nil in case if attributes not found.
func (t *Transaction) GetAttributes(typ AttrType) []Attribute {
var result []Attribute
for _, attr := range t.Attributes {
if attr.Type == typ {
result = append(result, attr)
}
}
return result
}
// decodeHashableFields decodes the fields that are used for signing the
// transaction, which are all fields except the scripts.
func (t *Transaction) decodeHashableFields(br *io.BinReader, buf []byte) {
var start, end int
if buf != nil {
start = len(buf) - br.Len()
}
t.Version = uint8(br.ReadB())
t.Nonce = br.ReadU32LE()
t.SystemFee = int64(br.ReadU64LE())
t.NetworkFee = int64(br.ReadU64LE())
t.ValidUntilBlock = br.ReadU32LE()
nsigners := br.ReadVarUint()
if br.Err != nil {
return
}
if nsigners > MaxAttributes {
br.Err = errors.New("too many signers")
return
} else if nsigners == 0 {
br.Err = errors.New("missing signers")
return
}
t.Signers = make([]Signer, nsigners)
for i := 0; i < int(nsigners); i++ {
t.Signers[i].DecodeBinary(br)
}
nattrs := br.ReadVarUint()
if nattrs > MaxAttributes-nsigners {
br.Err = errors.New("too many attributes")
return
}
t.Attributes = make([]Attribute, nattrs)
for i := 0; i < int(nattrs); i++ {
t.Attributes[i].DecodeBinary(br)
}
t.Script = br.ReadVarBytes(MaxScriptLength)
if br.Err == nil {
br.Err = t.isValid()
}
if buf != nil {
end = len(buf) - br.Len()
t.hash = hash.Sha256(buf[start:end])
t.hashed = true
}
}
func (t *Transaction) decodeBinaryNoSize(br *io.BinReader, buf []byte) {
t.decodeHashableFields(br, buf)
if br.Err != nil {
return
}
nscripts := br.ReadVarUint()
if nscripts > MaxAttributes {
br.Err = errors.New("too many witnesses")
return
} else if int(nscripts) != len(t.Signers) {
br.Err = fmt.Errorf("%w: %d vs %d", ErrInvalidWitnessNum, len(t.Signers), len(t.Scripts))
return
}
t.Scripts = make([]Witness, nscripts)
for i := 0; i < int(nscripts); i++ {
t.Scripts[i].DecodeBinary(br)
}
// Create the hash of the transaction at decode, so we dont need
// to do it anymore.
if br.Err == nil && buf == nil {
br.Err = t.createHash()
}
}
// DecodeBinary implements Serializable interface.
func (t *Transaction) DecodeBinary(br *io.BinReader) {
t.decodeBinaryNoSize(br, nil)
if br.Err == nil {
_ = t.Size()
}
}
// EncodeBinary implements Serializable interface.
func (t *Transaction) EncodeBinary(bw *io.BinWriter) {
t.encodeHashableFields(bw)
bw.WriteVarUint(uint64(len(t.Scripts)))
for i := range t.Scripts {
t.Scripts[i].EncodeBinary(bw)
}
}
// encodeHashableFields encodes the fields that are not used for
// signing the transaction, which are all fields except the scripts.
func (t *Transaction) encodeHashableFields(bw *io.BinWriter) {
if len(t.Script) == 0 {
bw.Err = errors.New("transaction has no script")
return
}
bw.WriteB(byte(t.Version))
bw.WriteU32LE(t.Nonce)
bw.WriteU64LE(uint64(t.SystemFee))
bw.WriteU64LE(uint64(t.NetworkFee))
bw.WriteU32LE(t.ValidUntilBlock)
bw.WriteVarUint(uint64(len(t.Signers)))
for i := range t.Signers {
t.Signers[i].EncodeBinary(bw)
}
bw.WriteVarUint(uint64(len(t.Attributes)))
for i := range t.Attributes {
t.Attributes[i].EncodeBinary(bw)
}
bw.WriteVarBytes(t.Script)
}
// EncodeHashableFields returns serialized transaction's fields which are hashed.
func (t *Transaction) EncodeHashableFields() ([]byte, error) {
bw := io.NewBufBinWriter()
t.encodeHashableFields(bw.BinWriter)
if bw.Err != nil {
return nil, bw.Err
}
return bw.Bytes(), nil
}
// createHash creates the hash of the transaction.
func (t *Transaction) createHash() error {
shaHash := sha256.New()
bw := io.NewBinWriterFromIO(shaHash)
t.encodeHashableFields(bw)
if bw.Err != nil {
return bw.Err
}
shaHash.Sum(t.hash[:0])
t.hashed = true
return nil
}
// DecodeHashableFields decodes a part of transaction which should be hashed.
func (t *Transaction) DecodeHashableFields(buf []byte) error {
r := io.NewBinReaderFromBuf(buf)
t.decodeHashableFields(r, buf)
if r.Err != nil {
return r.Err
}
// Ensure all the data was read.
if r.Len() != 0 {
return errors.New("additional data after the signed part")
}
t.Scripts = make([]Witness, 0)
return nil
}
// Bytes converts the transaction to []byte.
func (t *Transaction) Bytes() []byte {
buf := io.NewBufBinWriter()
t.EncodeBinary(buf.BinWriter)
if buf.Err != nil {
return nil
}
return buf.Bytes()
}
// NewTransactionFromBytes decodes byte array into *Transaction.
func NewTransactionFromBytes(b []byte) (*Transaction, error) {
tx := &Transaction{}
r := io.NewBinReaderFromBuf(b)
tx.decodeBinaryNoSize(r, b)
if r.Err != nil {
return nil, r.Err
}
if r.Len() != 0 {
return nil, errors.New("additional data after the transaction")
}
tx.size = len(b)
return tx, nil
}
// FeePerByte returns NetworkFee of the transaction divided by
// its size.
func (t *Transaction) FeePerByte() int64 {
return t.NetworkFee / int64(t.Size())
}
// Size returns size of the serialized transaction.
func (t *Transaction) Size() int {
if t.size == 0 {
t.size = io.GetVarSize(t)
}
return t.size
}
// Sender returns the sender of the transaction which is always on the first place
// in the transaction's signers list.
func (t *Transaction) Sender() util.Uint160 {
if len(t.Signers) == 0 {
panic("transaction does not have signers")
}
return t.Signers[0].Account
}
// transactionJSON is a wrapper for Transaction and
// used for correct marhalling of transaction.Data.
type transactionJSON struct {
TxID util.Uint256 `json:"hash"`
Size int `json:"size"`
Version uint8 `json:"version"`
Nonce uint32 `json:"nonce"`
Sender string `json:"sender"`
SystemFee int64 `json:"sysfee,string"`
| {
for i := range t.Attributes {
if t.Attributes[i].Type == typ {
return true
}
}
return false
} | identifier_body |
time_zones.rs | Formatter) -> fmt::Result {
write!(formatter, "LocalTimeConversionError")
}
}
/// Implemented for time zones where `LocalTimeConversionError` never occurs,
/// namely for `Utc` and `FixedOffsetFromUtc`.
///
/// Any UTC-offset change in a time zone creates local times that either don’t occur or occur twice.
/// `TimeZone::to_timestamp` returns `Err(LocalTimeConversionError)` for such local times.
pub trait UnambiguousTimeZone: TimeZone {
fn to_unambiguous_timestamp(&self, d: &NaiveDateTime) -> UnixTimestamp {
self.to_timestamp(d).unwrap()
}
}
/// The *Coordinated Universal Time* time time zone.
#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]
pub struct Utc;
impl UnambiguousTimeZone for Utc {}
impl TimeZone for Utc {
fn from_timestamp(&self, u: UnixTimestamp) -> NaiveDateTime {
let days_since_unix = div_floor(u.0, SECONDS_PER_DAY) as i32;
let days = days_since_unix + days_since_d0(1970);
let year = div_floor(days * 400, DAYS_PER_400YEARS) as i32;
let day_of_the_year = days - days_since_d0(year);
let (month, day) = Month::from_day_of_the_year(day_of_the_year, year.into());
let hour = positive_rem(div_floor(u.0, SECONDS_PER_HOUR), 24) as u8;
let minute = positive_rem(div_floor(u.0, SECONDS_PER_MINUTE), 60) as u8;
let second = positive_rem(u.0, 60) as u8;
NaiveDateTime::new(year, month, day, hour, minute, second)
}
fn to_timestamp(&self, d: &NaiveDateTime) -> Result<UnixTimestamp, LocalTimeConversionError> {
Ok(UnixTimestamp(
i64::from(days_since_unix(d)) * SECONDS_PER_DAY
+ i64::from(d.hour) * SECONDS_PER_HOUR
+ i64::from(d.minute) * SECONDS_PER_MINUTE
+ i64::from(d.second)
))
}
}
/// The offset is typically positive east of Greenwich (longitude 0°), negative west.
///
/// For example, Japan Standard Time is UTC+09:00:
///
/// ```rust
/// use gregor::FixedOffsetFromUtc;
/// let jst = FixedOffsetFromUtc::from_hours_and_minutes(9, 0);
/// ```
#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]
pub struct FixedOffsetFromUtc {
seconds_ahead_of_utc: i32,
}
impl FixedOffsetFromUtc {
pub fn from_hours_and_minutes(hours: i32, minutes: i32) -> Self {
FixedOffsetFromUtc {
seconds_ahead_of_utc: (hours * 60 + minutes) * 60,
}
}
}
impl UnambiguousTimeZone for FixedOffsetFromUtc {}
impl TimeZone for FixedOffsetFromUtc {
fn from_timestamp(&self, u: UnixTimestamp) -> NaiveDateTime {
// When local time is ahead of UTC (positive offset)
// that instant happened before midnight UTC
// so there are more seconds since then.
// (Add the offset rather than subtract it.)
// Seconds since *this time zone*’s midnight of 1970-01-01.
let seconds = u.0 + i64::from(self.seconds_ahead_of_utc);
// This is not really a Unix timestamp or a UTC date-time,
// but the two errors compensate to give a date-time in this time zone.
Utc.from_timestamp(UnixTimestamp(seconds))
}
fn to_timestamp(&self, d: &NaiveDateTime) -> Result<UnixTimestamp, LocalTimeConversionError> {
// Pretend this is UTC to obtain seconds since *this time zone*’s midnight of 1970-01-01.
let seconds = Utc.to_unambiguous_timestamp(d).0;
// For positives offsets (ahead of UTC) this is earlier in time than UTC midnight
// (with more seconds), so *subtract* the offset to make a Unix timestamp.
Ok(UnixTimestamp(seconds - i64::from(self.seconds_ahead_of_utc)))
}
}
pub trait DaylightSaving {
fn offset_outside_dst(&self) -> FixedOffsetFromUtc;
fn offset_during_dst(&self) -> FixedOffsetFromUtc;
fn is_in_dst(&self, t: UnixTimestamp) -> bool;
}
impl<Tz: DaylightSaving> TimeZone for Tz {
fn from_timestamp(&self, u: UnixTimestamp) -> NaiveDateTime {
let offset = if self.is_in_dst(u) {
self.offset_during_dst()
} else {
self.offset_outside_dst()
};
offset.from_timestamp(u)
}
fn to_timestamp(&self, d: &NaiveDateTime) -> Result<UnixTimestamp, LocalTimeConversionError> {
// The actual timestamp/instant is one of these two:
let assuming_outside = self.offset_outside_dst().to_unambiguous_timestamp(d);
let assuming_during = self.offset_during_dst().to_unambiguous_timestamp(d);
// Let’s take Central Europe for example.
// When converted to UTC, `assuming_outside` and `assuming_during` respectively
// represent date-times one hour and two hours before `d`.
// They are one hour apart.
//
// If both timestamps are in the same DST period (during DST or outside)
// then we know for sure which of `assuming_outside` or `assuming_during` is correct.
//
// If they disagree, that means their one hour span contains a DST change:
//
// * 1 am UTC is between `d - 2 hours` and `d - 1 hour`
// * `d - 2 hours` < 1am UTC, and 1am UTC <= `d - 1 hour`
// * `d` < 3 am local time, and 2 am local time <= `d`
// * `d` is between 2 am and 3 am local time.
//
// * In October when clocks go "back", this kind of local time happens twice the same day:
// it’s ambiguous.
// * In March when clocks go "forward", that hour is skipped entirely.
// This kind of local time does not exist. This `d` value might come from buggy code.
match (self.is_in_dst(assuming_outside), self.is_in_dst(assuming_during)) {
(true, true) => Ok(assuming_during),
(false, false) => Ok(assuming_outside),
_ => Err(LocalTimeConversionError { _private: () }),
}
}
}
/// CET (Central European Time) / CEST (Central European Summer Time)
#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]
pub struct CentralEurope;
impl DaylightSaving for CentralEurope {
fn offset_outs | FixedOffsetFromUtc {
FixedOffsetFromUtc::from_hours_and_minutes(1, 0)
}
fn offset_during_dst(&self) -> FixedOffsetFromUtc {
FixedOffsetFromUtc::from_hours_and_minutes(2, 0)
}
fn is_in_dst(&self, t: UnixTimestamp) -> bool {
use Month::*;
let d = DateTime::from_timestamp(t, Utc);
// Directive 2000/84/EC of the European Parliament and of the Council
// of 19 January 2001 on summer-time arrangements
// http://eur-lex.europa.eu/legal-content/EN/ALL/?uri=CELEX:32000L0084
//
// > Article 1
//
// > For the purposes of this Directive "summer-time period"
// > shall mean the period of the year
// > during which clocks are put forward by 60 minutes compared with the rest of the year.
// >
// > Article 2
// >
// > From 2002 onwards, the summer-time period shall begin, in every Member State,
// > at 1.00 a.m., Greenwich Mean Time, on the last Sunday in March.
// >
// > Article 3
// >
// > From 2002 onwards, the summer-time period shall end, in every Member State,
// > at 1.00 a.m., Greenwich Mean Time, on the last Sunday in October.
if d.month() < March || d.month() > October {
false
} else if d.month() > March && d.month() < October {
true
} else if d.month() == March {
!before_last_sunday_1_am(&d)
} else if d.month() == October {
before_last_sunday_1_am(&d)
} else {
unreachable!()
}
}
}
fn before_last_sunday_1_am(d: &DateTime<Utc>) -> bool {
let last_sunday = last_of_the_month(d, DayOfTheWeek::Sunday);
d.day() < last_sunday || (
d.day() == last_sunday &&
(d.hour(), d.minute(), d.second()) < (1, | ide_dst(&self) -> | identifier_name |
time_zones.rs | fn to_timestamp(&self, d: &NaiveDateTime) -> Result<UnixTimestamp, LocalTimeConversionError>;
}
/// When a time zone makes clock jump forward or back at any instant in time
/// (for example twice a year with daylight-saving time, a.k.a. summer-time period)
/// This error is returned when either:
///
/// * Clocks went back and this local time occurred at multiple instants in time,
/// making its interpretation or conversion ambiguous.
///
/// * Clocks jumped forward and this local time did not occur.
/// It does not represent any real instant in time.
/// It could be argued that a range of local times all represent the same instant,
/// but this library does not implement the conversion that way.
#[derive(Eq, PartialEq)]
pub struct LocalTimeConversionError {
/// Make the type opaque to allow for future extensions
_private: (),
}
impl fmt::Debug for LocalTimeConversionError {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "LocalTimeConversionError")
}
}
/// Implemented for time zones where `LocalTimeConversionError` never occurs,
/// namely for `Utc` and `FixedOffsetFromUtc`.
///
/// Any UTC-offset change in a time zone creates local times that either don’t occur or occur twice.
/// `TimeZone::to_timestamp` returns `Err(LocalTimeConversionError)` for such local times.
pub trait UnambiguousTimeZone: TimeZone {
fn to_unambiguous_timestamp(&self, d: &NaiveDateTime) -> UnixTimestamp {
self.to_timestamp(d).unwrap()
}
}
/// The *Coordinated Universal Time* time time zone.
#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]
pub struct Utc;
impl UnambiguousTimeZone for Utc {}
impl TimeZone for Utc {
fn from_timestamp(&self, u: UnixTimestamp) -> NaiveDateTime {
let days_since_unix = div_floor(u.0, SECONDS_PER_DAY) as i32;
let days = days_since_unix + days_since_d0(1970);
let year = div_floor(days * 400, DAYS_PER_400YEARS) as i32;
let day_of_the_year = days - days_since_d0(year);
let (month, day) = Month::from_day_of_the_year(day_of_the_year, year.into());
let hour = positive_rem(div_floor(u.0, SECONDS_PER_HOUR), 24) as u8;
let minute = positive_rem(div_floor(u.0, SECONDS_PER_MINUTE), 60) as u8;
let second = positive_rem(u.0, 60) as u8;
NaiveDateTime::new(year, month, day, hour, minute, second)
}
fn to_timestamp(&self, d: &NaiveDateTime) -> Result<UnixTimestamp, LocalTimeConversionError> {
Ok(UnixTimestamp(
i64::from(days_since_unix(d)) * SECONDS_PER_DAY
+ i64::from(d.hour) * SECONDS_PER_HOUR
+ i64::from(d.minute) * SECONDS_PER_MINUTE
+ i64::from(d.second)
))
}
}
/// The offset is typically positive east of Greenwich (longitude 0°), negative west.
///
/// For example, Japan Standard Time is UTC+09:00:
///
/// ```rust
/// use gregor::FixedOffsetFromUtc;
/// let jst = FixedOffsetFromUtc::from_hours_and_minutes(9, 0);
/// ```
#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]
pub struct FixedOffsetFromUtc {
seconds_ahead_of_utc: i32,
}
impl FixedOffsetFromUtc {
pub fn from_hours_and_minutes(hours: i32, minutes: i32) -> Self {
FixedOffsetFromUtc {
seconds_ahead_of_utc: (hours * 60 + minutes) * 60,
}
}
}
impl UnambiguousTimeZone for FixedOffsetFromUtc {}
impl TimeZone for FixedOffsetFromUtc {
fn from_timestamp(&self, u: UnixTimestamp) -> NaiveDateTime {
// When local time is ahead of UTC (positive offset)
// that instant happened before midnight UTC
// so there are more seconds since then.
// (Add the offset rather than subtract it.)
// Seconds since *this time zone*’s midnight of 1970-01-01.
let seconds = u.0 + i64::from(self.seconds_ahead_of_utc);
// This is not really a Unix timestamp or a UTC date-time,
// but the two errors compensate to give a date-time in this time zone.
Utc.from_timestamp(UnixTimestamp(seconds))
}
fn to_timestamp(&self, d: &NaiveDateTime) -> Result<UnixTimestamp, LocalTimeConversionError> {
// Pretend this is UTC to obtain seconds since *this time zone*’s midnight of 1970-01-01.
let seconds = Utc.to_unambiguous_timestamp(d).0;
// For positives offsets (ahead of UTC) this is earlier in time than UTC midnight
// (with more seconds), so *subtract* the offset to make a Unix timestamp.
Ok(UnixTimestamp(seconds - i64::from(self.seconds_ahead_of_utc)))
}
}
pub trait DaylightSaving {
fn offset_outside_dst(&self) -> FixedOffsetFromUtc;
fn offset_during_dst(&self) -> FixedOffsetFromUtc;
fn is_in_dst(&self, t: UnixTimestamp) -> bool;
}
impl<Tz: DaylightSaving> TimeZone for Tz {
fn from_timestamp(&self, u: UnixTimestamp) -> NaiveDateTime {
let offset = if self.is_in_dst(u) {
self.offset_during_dst()
} else {
self.offset_outside_dst()
};
offset.from_timestamp(u)
}
fn to_timestamp(&self, d: &NaiveDateTime) -> Result<UnixTimestamp, LocalTimeConversionError> {
// The actual timestamp/instant is one of these two:
let assuming_outside = self.offset_outside_dst().to_unambiguous_timestamp(d);
let assuming_during = self.offset_during_dst().to_unambiguous_timestamp(d);
// Let’s take Central Europe for example.
// When converted to UTC, `assuming_outside` and `assuming_during` respectively
// represent date-times one hour and two hours before `d`.
// They are one hour apart.
//
// If both timestamps are in the same DST period (during DST or outside)
// then we know for sure which of `assuming_outside` or `assuming_during` is correct.
//
// If they disagree, that means their one hour span contains a DST change:
//
// * 1 am UTC is between `d - 2 hours` and `d - 1 hour`
// * `d - 2 hours` < 1am UTC, and 1am UTC <= `d - 1 hour`
// * `d` < 3 am local time, and 2 am local time <= `d`
// * `d` is between 2 am and 3 am local time.
//
// * In October when clocks go "back", this kind of local time happens twice the same day:
// it’s ambiguous.
// * In March when clocks go "forward", that hour is skipped entirely.
// This kind of local time does not exist. This `d` value might come from buggy code.
match (self.is_in_dst(assuming_outside), self.is_in_dst(assuming_during)) {
(true, true) => Ok(assuming_during),
(false, false) => Ok(assuming_outside),
_ => Err(LocalTimeConversionError { _private: () }),
}
}
}
/// CET (Central European Time) / CEST (Central European Summer Time)
#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]
pub struct CentralEurope;
impl DaylightSaving for CentralEurope {
fn offset_outside_dst(&self) -> FixedOffsetFromUtc {
FixedOffsetFromUtc::from_hours_and_minutes(1, 0)
}
fn offset_during_dst(&self) -> FixedOffsetFromUtc {
FixedOffsetFromUtc::from_hours_and_minutes(2, 0)
}
fn is_in_dst(&self, t: UnixTimestamp) -> bool {
use Month::*;
let d = DateTime::from_timestamp(t, Utc);
// Directive 2000/84/EC of the European Parliament and of the Council
// of 19 January 2001 on summer-time arrangements
// http://eur-lex.europa.eu/legal-content/EN/ALL/?uri=CELEX:32000L0084
//
// > Article 1
//
// > For the purposes of this Directive "summer-time period"
// > shall mean the period of the year
// > during which clocks are put forward by 60 minutes compared with the rest of the year.
// >
// > Article 2
// >
// > From 2002 onwards, the summer-time period shall begin, in every Member State,
// > at 1.00 a.m., Greenwich Mean Time |
pub trait TimeZone {
fn from_timestamp(&self, t: UnixTimestamp) -> NaiveDateTime; | random_line_split | |
selector.rs | Err(io::Error::new(
io::ErrorKind::InvalidInput,
"Most-significant bit of token must remain unset.",
));
}
Ok(match reg_type {
RegType::Fd => key,
RegType::Handle => key | msb,
})
}
fn token_and_type_from_key(key: u64) -> (Token, RegType) {
let msb = 1u64 << 63;
(
Token((key & !msb) as usize),
if (key & msb) == 0 {
RegType::Fd
} else {
RegType::Handle
},
)
}
/// Each Selector has a globally unique(ish) ID associated with it. This ID
/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first
/// registered with the `Selector`. If a type that is previously associated with
/// a `Selector` attempts to register itself with a different `Selector`, the
/// operation will return with an error. This matches windows behavior.
static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT;
pub struct Selector {
id: usize,
/// Zircon object on which the handles have been registered, and on which events occur
port: Arc<zircon::Port>,
/// Whether or not `tokens_to_rereg` contains any elements. This is a best-effort attempt
/// used to prevent having to lock `tokens_to_rereg` when it is empty.
has_tokens_to_rereg: AtomicBool,
/// List of `Token`s corresponding to registrations that need to be reregistered before the
/// next `port::wait`. This is necessary to provide level-triggered behavior for
/// `Async::repeating` registrations.
///
/// When a level-triggered `Async::repeating` event is seen, its token is added to this list so
/// that it will be reregistered before the next `port::wait` call, making `port::wait` return
/// immediately if the signal was high during the reregistration.
///
/// Note: when used at the same time, the `tokens_to_rereg` lock should be taken out _before_
/// `token_to_fd`.
tokens_to_rereg: Mutex<Vec<Token>>,
/// Map from tokens to weak references to `EventedFdInner`-- a structure describing a
/// file handle, its associated `fdio` object, and its current registration.
token_to_fd: Mutex<hash_map::HashMap<Token, Weak<EventedFdInner>>>,
}
impl Selector {
pub fn new() -> io::Result<Selector> {
// Assertion from fuchsia/ready.rs to make sure that FuchsiaReady's representation is
// compatible with Ready.
assert_fuchsia_ready_repr();
let port = Arc::new(zircon::Port::create(zircon::PortOpts::Default)?);
// offset by 1 to avoid choosing 0 as the id of a selector
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1;
let has_tokens_to_rereg = AtomicBool::new(false);
let tokens_to_rereg = Mutex::new(Vec::new());
let token_to_fd = Mutex::new(hash_map::HashMap::new());
Ok(Selector {
id: id,
port: port,
has_tokens_to_rereg: has_tokens_to_rereg,
tokens_to_rereg: tokens_to_rereg,
token_to_fd: token_to_fd,
})
}
pub fn id(&self) -> usize {
self.id
}
/// Returns a reference to the underlying port `Arc`.
pub fn port(&self) -> &Arc<zircon::Port> {
&self.port
}
/// Reregisters all registrations pointed to by the `tokens_to_rereg` list
/// if `has_tokens_to_rereg`.
fn reregister_handles(&self) -> io::Result<()> {
// We use `Ordering::Acquire` to make sure that we see all `tokens_to_rereg`
// written before the store using `Ordering::Release`.
if self.has_tokens_to_rereg.load(Ordering::Acquire) {
let mut tokens = self.tokens_to_rereg.lock().unwrap();
let token_to_fd = self.token_to_fd.lock().unwrap();
for token in tokens.drain(0..) {
if let Some(eventedfd) = token_to_fd.get(&token).and_then(|h| h.upgrade())
{
eventedfd.rereg_for_level(&self.port);
}
}
self.has_tokens_to_rereg.store(false, Ordering::Release);
}
Ok(())
}
pub fn select(
&self,
evts: &mut Events,
_awakener: Token,
timeout: Option<Duration>,
) -> io::Result<bool> {
evts.clear();
self.reregister_handles()?;
let deadline = match timeout {
Some(duration) => {
let nanos = duration
.as_secs()
.saturating_mul(1_000_000_000)
.saturating_add(duration.subsec_nanos() as u64);
zircon::deadline_after(nanos)
}
None => zircon::ZX_TIME_INFINITE,
};
let packet = match self.port.wait(deadline) {
Ok(packet) => packet,
Err(zircon::Status::ErrTimedOut) => return Ok(false),
Err(e) => Err(e)?,
};
let observed_signals = match packet.contents() {
zircon::PacketContents::SignalOne(signal_packet) => signal_packet.observed(),
zircon::PacketContents::SignalRep(signal_packet) => signal_packet.observed(),
zircon::PacketContents::User(_user_packet) => {
// User packets are only ever sent by an Awakener
return Ok(true);
}
};
let key = packet.key();
let (token, reg_type) = token_and_type_from_key(key);
match reg_type {
RegType::Handle => {
// We can return immediately-- no lookup or registration necessary.
evts.events
.push(Event::new(Ready::from(observed_signals), token));
Ok(false)
}
RegType::Fd => {
// Convert the signals to epoll events using __fdio_wait_end,
// and add to reregistration list if necessary.
let events: u32;
{
let handle = if let Some(handle) = self
.token_to_fd
.lock()
.unwrap()
.get(&token)
.and_then(|h| h.upgrade())
{
handle
} else {
// This handle is apparently in the process of removal.
// It has been removed from the list, but port_cancel has not been called.
return Ok(false);
};
events = unsafe {
let mut events: u32 = mem::uninitialized();
sys::fuchsia::sys::__fdio_wait_end(
handle.fdio(),
observed_signals,
&mut events,
);
events
};
// If necessary, queue to be reregistered before next port_await
let needs_to_rereg = {
let registration_lock = handle.registration().lock().unwrap();
registration_lock
.as_ref()
.and_then(|r| r.rereg_signals())
.is_some()
};
if needs_to_rereg {
let mut tokens_to_rereg_lock =
self.tokens_to_rereg.lock().unwrap();
tokens_to_rereg_lock.push(token);
// We use `Ordering::Release` to make sure that we see all `tokens_to_rereg`
// written before the store.
self.has_tokens_to_rereg.store(true, Ordering::Release);
}
}
evts.events | .push(Event::new(epoll_event_to_ready(events), token));
Ok(false)
}
}
}
/// Register event interests for the given IO handle with the OS
pub fn register_fd(
&self,
handle: &zircon::Handle,
fd: &EventedFd,
token: Token,
signals: zircon::Signals,
poll_opts: PollOpt,
) -> io::Result<()> {
{
let mut token_to_fd = self.token_to_fd.lock().unwrap();
match token_to_fd.entry(token) {
hash_map::Entry::Occupied(_) => {
return Err(io::Error::new(
io::ErrorKind::AlreadyExists,
"Attempted to register a filedescriptor on an existing token.",
))
}
hash_map::Entry::Vacant(slot) => slot.insert(Arc::downgrade(&fd.inner)),
};
}
let wait_async_opts = poll_opts_to_wait_async(poll_opts);
let wait_res = handle.wait_async_handle(
&self.port,
token.0 as u64,
signals,
wait_async_opts,
);
if wait_res.is_err() {
self.token_to_fd.lock().unwrap().remove(&token);
}
Ok(wait_res?)
}
/// Deregister event interests for the given IO handle with the OS
pub fn deregister_fd(&self, handle: &zircon::Handle, token: Token) -> io::Result<()> {
self.token_to_fd.lock().unwrap().remove(&token);
// We ignore NotFound errors since oneshots are automatically deregistered,
// but mio will | random_line_split | |
selector.rs | (io::Error::new(
io::ErrorKind::InvalidInput,
"Most-significant bit of token must remain unset.",
));
}
Ok(match reg_type {
RegType::Fd => key,
RegType::Handle => key | msb,
})
}
fn token_and_type_from_key(key: u64) -> (Token, RegType) {
let msb = 1u64 << 63;
(
Token((key & !msb) as usize),
if (key & msb) == 0 {
RegType::Fd
} else {
RegType::Handle
},
)
}
/// Each Selector has a globally unique(ish) ID associated with it. This ID
/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first
/// registered with the `Selector`. If a type that is previously associated with
/// a `Selector` attempts to register itself with a different `Selector`, the
/// operation will return with an error. This matches windows behavior.
static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT;
pub struct Selector {
id: usize,
/// Zircon object on which the handles have been registered, and on which events occur
port: Arc<zircon::Port>,
/// Whether or not `tokens_to_rereg` contains any elements. This is a best-effort attempt
/// used to prevent having to lock `tokens_to_rereg` when it is empty.
has_tokens_to_rereg: AtomicBool,
/// List of `Token`s corresponding to registrations that need to be reregistered before the
/// next `port::wait`. This is necessary to provide level-triggered behavior for
/// `Async::repeating` registrations.
///
/// When a level-triggered `Async::repeating` event is seen, its token is added to this list so
/// that it will be reregistered before the next `port::wait` call, making `port::wait` return
/// immediately if the signal was high during the reregistration.
///
/// Note: when used at the same time, the `tokens_to_rereg` lock should be taken out _before_
/// `token_to_fd`.
tokens_to_rereg: Mutex<Vec<Token>>,
/// Map from tokens to weak references to `EventedFdInner`-- a structure describing a
/// file handle, its associated `fdio` object, and its current registration.
token_to_fd: Mutex<hash_map::HashMap<Token, Weak<EventedFdInner>>>,
}
impl Selector {
pub fn new() -> io::Result<Selector> {
// Assertion from fuchsia/ready.rs to make sure that FuchsiaReady's representation is
// compatible with Ready.
assert_fuchsia_ready_repr();
let port = Arc::new(zircon::Port::create(zircon::PortOpts::Default)?);
// offset by 1 to avoid choosing 0 as the id of a selector
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1;
let has_tokens_to_rereg = AtomicBool::new(false);
let tokens_to_rereg = Mutex::new(Vec::new());
let token_to_fd = Mutex::new(hash_map::HashMap::new());
Ok(Selector {
id: id,
port: port,
has_tokens_to_rereg: has_tokens_to_rereg,
tokens_to_rereg: tokens_to_rereg,
token_to_fd: token_to_fd,
})
}
pub fn id(&self) -> usize {
self.id
}
/// Returns a reference to the underlying port `Arc`.
pub fn | (&self) -> &Arc<zircon::Port> {
&self.port
}
/// Reregisters all registrations pointed to by the `tokens_to_rereg` list
/// if `has_tokens_to_rereg`.
fn reregister_handles(&self) -> io::Result<()> {
// We use `Ordering::Acquire` to make sure that we see all `tokens_to_rereg`
// written before the store using `Ordering::Release`.
if self.has_tokens_to_rereg.load(Ordering::Acquire) {
let mut tokens = self.tokens_to_rereg.lock().unwrap();
let token_to_fd = self.token_to_fd.lock().unwrap();
for token in tokens.drain(0..) {
if let Some(eventedfd) = token_to_fd.get(&token).and_then(|h| h.upgrade())
{
eventedfd.rereg_for_level(&self.port);
}
}
self.has_tokens_to_rereg.store(false, Ordering::Release);
}
Ok(())
}
pub fn select(
&self,
evts: &mut Events,
_awakener: Token,
timeout: Option<Duration>,
) -> io::Result<bool> {
evts.clear();
self.reregister_handles()?;
let deadline = match timeout {
Some(duration) => {
let nanos = duration
.as_secs()
.saturating_mul(1_000_000_000)
.saturating_add(duration.subsec_nanos() as u64);
zircon::deadline_after(nanos)
}
None => zircon::ZX_TIME_INFINITE,
};
let packet = match self.port.wait(deadline) {
Ok(packet) => packet,
Err(zircon::Status::ErrTimedOut) => return Ok(false),
Err(e) => Err(e)?,
};
let observed_signals = match packet.contents() {
zircon::PacketContents::SignalOne(signal_packet) => signal_packet.observed(),
zircon::PacketContents::SignalRep(signal_packet) => signal_packet.observed(),
zircon::PacketContents::User(_user_packet) => {
// User packets are only ever sent by an Awakener
return Ok(true);
}
};
let key = packet.key();
let (token, reg_type) = token_and_type_from_key(key);
match reg_type {
RegType::Handle => {
// We can return immediately-- no lookup or registration necessary.
evts.events
.push(Event::new(Ready::from(observed_signals), token));
Ok(false)
}
RegType::Fd => {
// Convert the signals to epoll events using __fdio_wait_end,
// and add to reregistration list if necessary.
let events: u32;
{
let handle = if let Some(handle) = self
.token_to_fd
.lock()
.unwrap()
.get(&token)
.and_then(|h| h.upgrade())
{
handle
} else {
// This handle is apparently in the process of removal.
// It has been removed from the list, but port_cancel has not been called.
return Ok(false);
};
events = unsafe {
let mut events: u32 = mem::uninitialized();
sys::fuchsia::sys::__fdio_wait_end(
handle.fdio(),
observed_signals,
&mut events,
);
events
};
// If necessary, queue to be reregistered before next port_await
let needs_to_rereg = {
let registration_lock = handle.registration().lock().unwrap();
registration_lock
.as_ref()
.and_then(|r| r.rereg_signals())
.is_some()
};
if needs_to_rereg {
let mut tokens_to_rereg_lock =
self.tokens_to_rereg.lock().unwrap();
tokens_to_rereg_lock.push(token);
// We use `Ordering::Release` to make sure that we see all `tokens_to_rereg`
// written before the store.
self.has_tokens_to_rereg.store(true, Ordering::Release);
}
}
evts.events
.push(Event::new(epoll_event_to_ready(events), token));
Ok(false)
}
}
}
/// Register event interests for the given IO handle with the OS
pub fn register_fd(
&self,
handle: &zircon::Handle,
fd: &EventedFd,
token: Token,
signals: zircon::Signals,
poll_opts: PollOpt,
) -> io::Result<()> {
{
let mut token_to_fd = self.token_to_fd.lock().unwrap();
match token_to_fd.entry(token) {
hash_map::Entry::Occupied(_) => {
return Err(io::Error::new(
io::ErrorKind::AlreadyExists,
"Attempted to register a filedescriptor on an existing token.",
))
}
hash_map::Entry::Vacant(slot) => slot.insert(Arc::downgrade(&fd.inner)),
};
}
let wait_async_opts = poll_opts_to_wait_async(poll_opts);
let wait_res = handle.wait_async_handle(
&self.port,
token.0 as u64,
signals,
wait_async_opts,
);
if wait_res.is_err() {
self.token_to_fd.lock().unwrap().remove(&token);
}
Ok(wait_res?)
}
/// Deregister event interests for the given IO handle with the OS
pub fn deregister_fd(&self, handle: &zircon::Handle, token: Token) -> io::Result<()> {
self.token_to_fd.lock().unwrap().remove(&token);
// We ignore NotFound errors since oneshots are automatically deregistered,
// but mio | port | identifier_name |
selector.rs | (io::Error::new(
io::ErrorKind::InvalidInput,
"Most-significant bit of token must remain unset.",
));
}
Ok(match reg_type {
RegType::Fd => key,
RegType::Handle => key | msb,
})
}
fn token_and_type_from_key(key: u64) -> (Token, RegType) {
let msb = 1u64 << 63;
(
Token((key & !msb) as usize),
if (key & msb) == 0 {
RegType::Fd
} else {
RegType::Handle
},
)
}
/// Each Selector has a globally unique(ish) ID associated with it. This ID
/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first
/// registered with the `Selector`. If a type that is previously associated with
/// a `Selector` attempts to register itself with a different `Selector`, the
/// operation will return with an error. This matches windows behavior.
static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT;
pub struct Selector {
id: usize,
/// Zircon object on which the handles have been registered, and on which events occur
port: Arc<zircon::Port>,
/// Whether or not `tokens_to_rereg` contains any elements. This is a best-effort attempt
/// used to prevent having to lock `tokens_to_rereg` when it is empty.
has_tokens_to_rereg: AtomicBool,
/// List of `Token`s corresponding to registrations that need to be reregistered before the
/// next `port::wait`. This is necessary to provide level-triggered behavior for
/// `Async::repeating` registrations.
///
/// When a level-triggered `Async::repeating` event is seen, its token is added to this list so
/// that it will be reregistered before the next `port::wait` call, making `port::wait` return
/// immediately if the signal was high during the reregistration.
///
/// Note: when used at the same time, the `tokens_to_rereg` lock should be taken out _before_
/// `token_to_fd`.
tokens_to_rereg: Mutex<Vec<Token>>,
/// Map from tokens to weak references to `EventedFdInner`-- a structure describing a
/// file handle, its associated `fdio` object, and its current registration.
token_to_fd: Mutex<hash_map::HashMap<Token, Weak<EventedFdInner>>>,
}
impl Selector {
pub fn new() -> io::Result<Selector> {
// Assertion from fuchsia/ready.rs to make sure that FuchsiaReady's representation is
// compatible with Ready.
assert_fuchsia_ready_repr();
let port = Arc::new(zircon::Port::create(zircon::PortOpts::Default)?);
// offset by 1 to avoid choosing 0 as the id of a selector
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1;
let has_tokens_to_rereg = AtomicBool::new(false);
let tokens_to_rereg = Mutex::new(Vec::new());
let token_to_fd = Mutex::new(hash_map::HashMap::new());
Ok(Selector {
id: id,
port: port,
has_tokens_to_rereg: has_tokens_to_rereg,
tokens_to_rereg: tokens_to_rereg,
token_to_fd: token_to_fd,
})
}
pub fn id(&self) -> usize {
self.id
}
/// Returns a reference to the underlying port `Arc`.
pub fn port(&self) -> &Arc<zircon::Port> {
&self.port
}
/// Reregisters all registrations pointed to by the `tokens_to_rereg` list
/// if `has_tokens_to_rereg`.
fn reregister_handles(&self) -> io::Result<()> {
// We use `Ordering::Acquire` to make sure that we see all `tokens_to_rereg`
// written before the store using `Ordering::Release`.
if self.has_tokens_to_rereg.load(Ordering::Acquire) {
let mut tokens = self.tokens_to_rereg.lock().unwrap();
let token_to_fd = self.token_to_fd.lock().unwrap();
for token in tokens.drain(0..) {
if let Some(eventedfd) = token_to_fd.get(&token).and_then(|h| h.upgrade())
{
eventedfd.rereg_for_level(&self.port);
}
}
self.has_tokens_to_rereg.store(false, Ordering::Release);
}
Ok(())
}
pub fn select(
&self,
evts: &mut Events,
_awakener: Token,
timeout: Option<Duration>,
) -> io::Result<bool> {
evts.clear();
self.reregister_handles()?;
let deadline = match timeout {
Some(duration) => |
None => zircon::ZX_TIME_INFINITE,
};
let packet = match self.port.wait(deadline) {
Ok(packet) => packet,
Err(zircon::Status::ErrTimedOut) => return Ok(false),
Err(e) => Err(e)?,
};
let observed_signals = match packet.contents() {
zircon::PacketContents::SignalOne(signal_packet) => signal_packet.observed(),
zircon::PacketContents::SignalRep(signal_packet) => signal_packet.observed(),
zircon::PacketContents::User(_user_packet) => {
// User packets are only ever sent by an Awakener
return Ok(true);
}
};
let key = packet.key();
let (token, reg_type) = token_and_type_from_key(key);
match reg_type {
RegType::Handle => {
// We can return immediately-- no lookup or registration necessary.
evts.events
.push(Event::new(Ready::from(observed_signals), token));
Ok(false)
}
RegType::Fd => {
// Convert the signals to epoll events using __fdio_wait_end,
// and add to reregistration list if necessary.
let events: u32;
{
let handle = if let Some(handle) = self
.token_to_fd
.lock()
.unwrap()
.get(&token)
.and_then(|h| h.upgrade())
{
handle
} else {
// This handle is apparently in the process of removal.
// It has been removed from the list, but port_cancel has not been called.
return Ok(false);
};
events = unsafe {
let mut events: u32 = mem::uninitialized();
sys::fuchsia::sys::__fdio_wait_end(
handle.fdio(),
observed_signals,
&mut events,
);
events
};
// If necessary, queue to be reregistered before next port_await
let needs_to_rereg = {
let registration_lock = handle.registration().lock().unwrap();
registration_lock
.as_ref()
.and_then(|r| r.rereg_signals())
.is_some()
};
if needs_to_rereg {
let mut tokens_to_rereg_lock =
self.tokens_to_rereg.lock().unwrap();
tokens_to_rereg_lock.push(token);
// We use `Ordering::Release` to make sure that we see all `tokens_to_rereg`
// written before the store.
self.has_tokens_to_rereg.store(true, Ordering::Release);
}
}
evts.events
.push(Event::new(epoll_event_to_ready(events), token));
Ok(false)
}
}
}
/// Register event interests for the given IO handle with the OS
pub fn register_fd(
&self,
handle: &zircon::Handle,
fd: &EventedFd,
token: Token,
signals: zircon::Signals,
poll_opts: PollOpt,
) -> io::Result<()> {
{
let mut token_to_fd = self.token_to_fd.lock().unwrap();
match token_to_fd.entry(token) {
hash_map::Entry::Occupied(_) => {
return Err(io::Error::new(
io::ErrorKind::AlreadyExists,
"Attempted to register a filedescriptor on an existing token.",
))
}
hash_map::Entry::Vacant(slot) => slot.insert(Arc::downgrade(&fd.inner)),
};
}
let wait_async_opts = poll_opts_to_wait_async(poll_opts);
let wait_res = handle.wait_async_handle(
&self.port,
token.0 as u64,
signals,
wait_async_opts,
);
if wait_res.is_err() {
self.token_to_fd.lock().unwrap().remove(&token);
}
Ok(wait_res?)
}
/// Deregister event interests for the given IO handle with the OS
pub fn deregister_fd(&self, handle: &zircon::Handle, token: Token) -> io::Result<()> {
self.token_to_fd.lock().unwrap().remove(&token);
// We ignore NotFound errors since oneshots are automatically deregistered,
// but | {
let nanos = duration
.as_secs()
.saturating_mul(1_000_000_000)
.saturating_add(duration.subsec_nanos() as u64);
zircon::deadline_after(nanos)
} | conditional_block |
selector.rs | RegType) {
let msb = 1u64 << 63;
(
Token((key & !msb) as usize),
if (key & msb) == 0 {
RegType::Fd
} else {
RegType::Handle
},
)
}
/// Each Selector has a globally unique(ish) ID associated with it. This ID
/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first
/// registered with the `Selector`. If a type that is previously associated with
/// a `Selector` attempts to register itself with a different `Selector`, the
/// operation will return with an error. This matches windows behavior.
static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT;
pub struct Selector {
id: usize,
/// Zircon object on which the handles have been registered, and on which events occur
port: Arc<zircon::Port>,
/// Whether or not `tokens_to_rereg` contains any elements. This is a best-effort attempt
/// used to prevent having to lock `tokens_to_rereg` when it is empty.
has_tokens_to_rereg: AtomicBool,
/// List of `Token`s corresponding to registrations that need to be reregistered before the
/// next `port::wait`. This is necessary to provide level-triggered behavior for
/// `Async::repeating` registrations.
///
/// When a level-triggered `Async::repeating` event is seen, its token is added to this list so
/// that it will be reregistered before the next `port::wait` call, making `port::wait` return
/// immediately if the signal was high during the reregistration.
///
/// Note: when used at the same time, the `tokens_to_rereg` lock should be taken out _before_
/// `token_to_fd`.
tokens_to_rereg: Mutex<Vec<Token>>,
/// Map from tokens to weak references to `EventedFdInner`-- a structure describing a
/// file handle, its associated `fdio` object, and its current registration.
token_to_fd: Mutex<hash_map::HashMap<Token, Weak<EventedFdInner>>>,
}
impl Selector {
pub fn new() -> io::Result<Selector> {
// Assertion from fuchsia/ready.rs to make sure that FuchsiaReady's representation is
// compatible with Ready.
assert_fuchsia_ready_repr();
let port = Arc::new(zircon::Port::create(zircon::PortOpts::Default)?);
// offset by 1 to avoid choosing 0 as the id of a selector
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1;
let has_tokens_to_rereg = AtomicBool::new(false);
let tokens_to_rereg = Mutex::new(Vec::new());
let token_to_fd = Mutex::new(hash_map::HashMap::new());
Ok(Selector {
id: id,
port: port,
has_tokens_to_rereg: has_tokens_to_rereg,
tokens_to_rereg: tokens_to_rereg,
token_to_fd: token_to_fd,
})
}
pub fn id(&self) -> usize {
self.id
}
/// Returns a reference to the underlying port `Arc`.
pub fn port(&self) -> &Arc<zircon::Port> {
&self.port
}
/// Reregisters all registrations pointed to by the `tokens_to_rereg` list
/// if `has_tokens_to_rereg`.
fn reregister_handles(&self) -> io::Result<()> {
// We use `Ordering::Acquire` to make sure that we see all `tokens_to_rereg`
// written before the store using `Ordering::Release`.
if self.has_tokens_to_rereg.load(Ordering::Acquire) {
let mut tokens = self.tokens_to_rereg.lock().unwrap();
let token_to_fd = self.token_to_fd.lock().unwrap();
for token in tokens.drain(0..) {
if let Some(eventedfd) = token_to_fd.get(&token).and_then(|h| h.upgrade())
{
eventedfd.rereg_for_level(&self.port);
}
}
self.has_tokens_to_rereg.store(false, Ordering::Release);
}
Ok(())
}
pub fn select(
&self,
evts: &mut Events,
_awakener: Token,
timeout: Option<Duration>,
) -> io::Result<bool> {
evts.clear();
self.reregister_handles()?;
let deadline = match timeout {
Some(duration) => {
let nanos = duration
.as_secs()
.saturating_mul(1_000_000_000)
.saturating_add(duration.subsec_nanos() as u64);
zircon::deadline_after(nanos)
}
None => zircon::ZX_TIME_INFINITE,
};
let packet = match self.port.wait(deadline) {
Ok(packet) => packet,
Err(zircon::Status::ErrTimedOut) => return Ok(false),
Err(e) => Err(e)?,
};
let observed_signals = match packet.contents() {
zircon::PacketContents::SignalOne(signal_packet) => signal_packet.observed(),
zircon::PacketContents::SignalRep(signal_packet) => signal_packet.observed(),
zircon::PacketContents::User(_user_packet) => {
// User packets are only ever sent by an Awakener
return Ok(true);
}
};
let key = packet.key();
let (token, reg_type) = token_and_type_from_key(key);
match reg_type {
RegType::Handle => {
// We can return immediately-- no lookup or registration necessary.
evts.events
.push(Event::new(Ready::from(observed_signals), token));
Ok(false)
}
RegType::Fd => {
// Convert the signals to epoll events using __fdio_wait_end,
// and add to reregistration list if necessary.
let events: u32;
{
let handle = if let Some(handle) = self
.token_to_fd
.lock()
.unwrap()
.get(&token)
.and_then(|h| h.upgrade())
{
handle
} else {
// This handle is apparently in the process of removal.
// It has been removed from the list, but port_cancel has not been called.
return Ok(false);
};
events = unsafe {
let mut events: u32 = mem::uninitialized();
sys::fuchsia::sys::__fdio_wait_end(
handle.fdio(),
observed_signals,
&mut events,
);
events
};
// If necessary, queue to be reregistered before next port_await
let needs_to_rereg = {
let registration_lock = handle.registration().lock().unwrap();
registration_lock
.as_ref()
.and_then(|r| r.rereg_signals())
.is_some()
};
if needs_to_rereg {
let mut tokens_to_rereg_lock =
self.tokens_to_rereg.lock().unwrap();
tokens_to_rereg_lock.push(token);
// We use `Ordering::Release` to make sure that we see all `tokens_to_rereg`
// written before the store.
self.has_tokens_to_rereg.store(true, Ordering::Release);
}
}
evts.events
.push(Event::new(epoll_event_to_ready(events), token));
Ok(false)
}
}
}
/// Register event interests for the given IO handle with the OS
pub fn register_fd(
&self,
handle: &zircon::Handle,
fd: &EventedFd,
token: Token,
signals: zircon::Signals,
poll_opts: PollOpt,
) -> io::Result<()> {
{
let mut token_to_fd = self.token_to_fd.lock().unwrap();
match token_to_fd.entry(token) {
hash_map::Entry::Occupied(_) => {
return Err(io::Error::new(
io::ErrorKind::AlreadyExists,
"Attempted to register a filedescriptor on an existing token.",
))
}
hash_map::Entry::Vacant(slot) => slot.insert(Arc::downgrade(&fd.inner)),
};
}
let wait_async_opts = poll_opts_to_wait_async(poll_opts);
let wait_res = handle.wait_async_handle(
&self.port,
token.0 as u64,
signals,
wait_async_opts,
);
if wait_res.is_err() {
self.token_to_fd.lock().unwrap().remove(&token);
}
Ok(wait_res?)
}
/// Deregister event interests for the given IO handle with the OS
pub fn deregister_fd(&self, handle: &zircon::Handle, token: Token) -> io::Result<()> | {
self.token_to_fd.lock().unwrap().remove(&token);
// We ignore NotFound errors since oneshots are automatically deregistered,
// but mio will attempt to deregister them manually.
self.port
.cancel(&*handle, token.0 as u64)
.map_err(io::Error::from)
.or_else(|e| {
if e.kind() == io::ErrorKind::NotFound {
Ok(())
} else {
Err(e)
}
})
} | identifier_body | |
policy_distillation.py | _size, self.hidden_size),
nn.ReLU(inplace=True),
nn.Linear(self.hidden_size, self.output_size)
)
def forward(self, input):
input = input.view(-1, self.input_size)
return F.softmax(self.fc(input), dim=1)
class CNNPolicy(nn.Module):
def __init__(self, output_size, img_shape):
super(CNNPolicy, self).__init__()
self.model = CustomCNN(state_dim=output_size, img_shape=img_shape)
def forward(self, input):
return F.softmax(self.model(input), dim=1)
class PolicyDistillationModel(BaseRLObject):
"""
Implementation of PolicyDistillation
"""
def __init__(self):
super(PolicyDistillationModel, self).__init__()
def | (self, save_path, _locals=None):
assert self.model is not None, "Error: must train or load model before use"
with open(save_path, "wb") as f:
pickle.dump(self.__dict__, f)
@classmethod
def load(cls, load_path, args=None):
with open(load_path, "rb") as f:
class_dict = pickle.load(f)
loaded_model = PolicyDistillationModel()
loaded_model.__dict__ = class_dict
return loaded_model
def customArguments(self, parser):
parser.add_argument('--nothing4instance', help='Number of population (each one has 2 threads)', type=bool,
default=True)
return parser
def getActionProba(self, observation, dones=None, delta=0):
"""
returns the action probability distribution, from a given observation.
:param observation: (numpy int or numpy float)
:param dones: ([bool])
:param delta: (numpy float or float) The exploration noise applied to the policy, set to 0 for no noise.
:return: (numpy float)
"""
assert self.model is not None, "Error: must train or load model before use"
if len(observation.shape) > 2:
observation = np.transpose(observation, (0, 3, 2, 1))
observation = th.from_numpy(observation).float().requires_grad_(False).to(self.device)
action = self.model.forward(observation).detach().cpu().numpy()
return action
def getAction(self, observation, dones=None, delta=0, sample=False):
"""
From an observation returns the associated action
:param observation: (numpy int or numpy float)
:param dones: ([bool])
:param delta: (numpy float or float) The exploration noise applied to the policy, set to 0 for no noise.
:return: (numpy float)
"""
assert self.model is not None, "Error: must train or load model before use"
self.model.eval()
if len(observation.shape) > 2:
observation = np.transpose(observation, (0, 3, 2, 1))
observation = th.from_numpy(observation).float().requires_grad_(False).to(self.device)
if sample:
proba_actions = self.model.forward(observation).detach().cpu().numpy().flatten()
return np.random.choice(range(len(proba_actions)), 1, p=proba_actions)
else:
return [np.argmax(self.model.forward(observation).detach().cpu().numpy())]
def loss_fn_kd(self, outputs, teacher_outputs, labels=None, adaptive_temperature=False):
"""
Hyperparameters: temperature and alpha
:param outputs: output from the student model
:param teacher_outputs: output from the teacher_outputs model
:return: loss
"""
if labels is not None and adaptive_temperature:
T = th.from_numpy(np.array([TEMPERATURES[labels[idx_elm]] for idx_elm in range(BATCH_SIZE)])).cuda().float()
KD_loss = F.softmax(th.div(teacher_outputs.transpose(1, 0), T), dim=1) * \
th.log((F.softmax(th.div(teacher_outputs.transpose(1, 0), T), dim=1) / F.softmax(outputs.transpose(1,0), dim=1)))
else:
T = TEMPERATURES["default"]
print('1',teacher_outputs.size())
print('2', outputs.size())
KD_loss = F.softmax(teacher_outputs/T, dim=1) * \
th.log((F.softmax(teacher_outputs/T, dim=1) / F.softmax(outputs, dim=1)))
print(KD_loss.size())
return KD_loss.mean()
def loss_mse(self, outputs, teacher_outputs):
return (outputs - teacher_outputs).pow(2).sum(1).mean()
def train(self, args, callback, env_kwargs=None, train_kwargs=None):
N_EPOCHS = args.epochs_distillation
self.seed = args.seed
self.batch_size = BATCH_SIZE
print("We assumed SRL training already done")
print('Loading data for distillation ')
# training_data, ground_truth, true_states, _ = loadData(args.teacher_data_folder)
training_data, ground_truth, _, _ = loadData(args.teacher_data_folder, with_env=False)
images_path = ground_truth['images_path']
episode_starts = training_data['episode_starts']
actions = training_data['actions']
actions_proba = training_data['actions_proba']
if USE_ADAPTIVE_TEMPERATURE:
cl_labels = training_data[CL_LABEL_KEY]
else:
cl_labels_st = None
if args.distillation_training_set_size > 0:
limit = args.distillation_training_set_size
actions = actions[:limit]
images_path = images_path[:limit]
episode_starts = episode_starts[:limit]
images_path_copy = [images_path[k] for k in range(images_path.shape[0])]
images_path = np.array(images_path_copy)
num_samples = images_path.shape[0] - 1 # number of samples
if args.img_shape is None:
self.img_shape = None #(3,224,224)
else:
self.img_shape = tuple(map(int, args.img_shape[1:-1].split(",")))
# indices for all time steps where the episode continues
indices = np.array([i for i in range(num_samples) if not episode_starts[i + 1]], dtype='int64')
np.random.shuffle(indices)
# split indices into minibatches. minibatchlist is a list of lists; each
# list is the id of the observation preserved through the training
minibatchlist = [np.array(sorted(indices[start_idx:start_idx + self.batch_size]))
for start_idx in range(0, len(indices) - self.batch_size + 1, self.batch_size)]
data_loader = DataLoader(minibatchlist, images_path, self.img_shape, n_workers=N_WORKERS, multi_view=False,
use_triplets=False, is_training=True,absolute_path=False)
test_minibatchlist = DataLoader.createTestMinibatchList(len(images_path), MAX_BATCH_SIZE_GPU)
test_data_loader = DataLoader(test_minibatchlist, images_path, self.img_shape, n_workers=N_WORKERS, multi_view=False,
use_triplets=False, max_queue_len=1, is_training=False,absolute_path=False)
# Number of minibatches used for validation:
n_val_batches = np.round(VALIDATION_SIZE * len(minibatchlist)).astype(np.int64)
val_indices = np.random.permutation(len(minibatchlist))[:n_val_batches]
# Print some info
print("{} minibatches for training, {} samples".format(len(minibatchlist) - n_val_batches,
(len(minibatchlist) - n_val_batches) * BATCH_SIZE))
print("{} minibatches for validation, {} samples".format(n_val_batches, n_val_batches * BATCH_SIZE))
assert n_val_batches > 0, "Not enough sample to create a validation set"
# Stats about actions
if not args.continuous_actions:
print('Discrete action space:')
action_set = set(actions)
n_actions = int(np.max(actions) + 1)
print("{} unique actions / {} actions".format(len(action_set), n_actions))
n_obs_per_action = np.zeros(n_actions, dtype=np.int64)
for i in range(n_actions):
n_obs_per_action[i] = np.sum(actions == i)
print("Number of observations per action")
print(n_obs_per_action)
else:
print('Continuous action space:')
print('Action dimension: {}'.format(self.dim_action))
# Here the default SRL model is assumed to be raw_pixels
self.state_dim = self.img_shape[0] * self.img_shape[1] * self.img_shape[2] # why
self.srl_model = None
print("env_kwargs[srl_model] ",env_kwargs["srl_model"])
# TODO: add sanity checks & test for all possible SRL for distillation
if env_kwargs["srl_model"] == "raw_pixels":
# if the pilicy distillation is used with raw pixel
self.model = CNNPolicy(n_actions, self.img_shape)
learnable_params = self.model.parameters()
learning_rate = 1e-3
else:
self.state_dim = getSRLDim(env_kwargs.get("srl_model_path", None))
self.srl_model = loadSRLModel(env_kwargs.get("srl_model_path", None),
th.cuda.is_available(), self.state_dim, env_object=None)
self.model = MLPPolicy(output_size=n | save | identifier_name |
policy_distillation.py | , img_shape=img_shape)
def forward(self, input):
return F.softmax(self.model(input), dim=1)
class PolicyDistillationModel(BaseRLObject):
"""
Implementation of PolicyDistillation
"""
def __init__(self):
super(PolicyDistillationModel, self).__init__()
def save(self, save_path, _locals=None):
assert self.model is not None, "Error: must train or load model before use"
with open(save_path, "wb") as f:
pickle.dump(self.__dict__, f)
@classmethod
def load(cls, load_path, args=None):
with open(load_path, "rb") as f:
class_dict = pickle.load(f)
loaded_model = PolicyDistillationModel()
loaded_model.__dict__ = class_dict
return loaded_model
def customArguments(self, parser):
parser.add_argument('--nothing4instance', help='Number of population (each one has 2 threads)', type=bool,
default=True)
return parser
def getActionProba(self, observation, dones=None, delta=0):
"""
returns the action probability distribution, from a given observation.
:param observation: (numpy int or numpy float)
:param dones: ([bool])
:param delta: (numpy float or float) The exploration noise applied to the policy, set to 0 for no noise.
:return: (numpy float)
"""
assert self.model is not None, "Error: must train or load model before use"
if len(observation.shape) > 2:
observation = np.transpose(observation, (0, 3, 2, 1))
observation = th.from_numpy(observation).float().requires_grad_(False).to(self.device)
action = self.model.forward(observation).detach().cpu().numpy()
return action
def getAction(self, observation, dones=None, delta=0, sample=False):
"""
From an observation returns the associated action
:param observation: (numpy int or numpy float)
:param dones: ([bool])
:param delta: (numpy float or float) The exploration noise applied to the policy, set to 0 for no noise.
:return: (numpy float)
"""
assert self.model is not None, "Error: must train or load model before use"
self.model.eval()
if len(observation.shape) > 2:
observation = np.transpose(observation, (0, 3, 2, 1))
observation = th.from_numpy(observation).float().requires_grad_(False).to(self.device)
if sample:
proba_actions = self.model.forward(observation).detach().cpu().numpy().flatten()
return np.random.choice(range(len(proba_actions)), 1, p=proba_actions)
else:
return [np.argmax(self.model.forward(observation).detach().cpu().numpy())]
def loss_fn_kd(self, outputs, teacher_outputs, labels=None, adaptive_temperature=False):
"""
Hyperparameters: temperature and alpha
:param outputs: output from the student model
:param teacher_outputs: output from the teacher_outputs model
:return: loss
"""
if labels is not None and adaptive_temperature:
T = th.from_numpy(np.array([TEMPERATURES[labels[idx_elm]] for idx_elm in range(BATCH_SIZE)])).cuda().float()
KD_loss = F.softmax(th.div(teacher_outputs.transpose(1, 0), T), dim=1) * \
th.log((F.softmax(th.div(teacher_outputs.transpose(1, 0), T), dim=1) / F.softmax(outputs.transpose(1,0), dim=1)))
else:
T = TEMPERATURES["default"]
print('1',teacher_outputs.size())
print('2', outputs.size())
KD_loss = F.softmax(teacher_outputs/T, dim=1) * \
th.log((F.softmax(teacher_outputs/T, dim=1) / F.softmax(outputs, dim=1)))
print(KD_loss.size())
return KD_loss.mean()
def loss_mse(self, outputs, teacher_outputs):
return (outputs - teacher_outputs).pow(2).sum(1).mean()
def train(self, args, callback, env_kwargs=None, train_kwargs=None):
N_EPOCHS = args.epochs_distillation
self.seed = args.seed
self.batch_size = BATCH_SIZE
print("We assumed SRL training already done")
print('Loading data for distillation ')
# training_data, ground_truth, true_states, _ = loadData(args.teacher_data_folder)
training_data, ground_truth, _, _ = loadData(args.teacher_data_folder, with_env=False)
images_path = ground_truth['images_path']
episode_starts = training_data['episode_starts']
actions = training_data['actions']
actions_proba = training_data['actions_proba']
if USE_ADAPTIVE_TEMPERATURE:
cl_labels = training_data[CL_LABEL_KEY]
else:
cl_labels_st = None
if args.distillation_training_set_size > 0:
limit = args.distillation_training_set_size
actions = actions[:limit]
images_path = images_path[:limit]
episode_starts = episode_starts[:limit]
images_path_copy = [images_path[k] for k in range(images_path.shape[0])]
images_path = np.array(images_path_copy)
num_samples = images_path.shape[0] - 1 # number of samples
if args.img_shape is None:
self.img_shape = None #(3,224,224)
else:
self.img_shape = tuple(map(int, args.img_shape[1:-1].split(",")))
# indices for all time steps where the episode continues
indices = np.array([i for i in range(num_samples) if not episode_starts[i + 1]], dtype='int64')
np.random.shuffle(indices)
# split indices into minibatches. minibatchlist is a list of lists; each
# list is the id of the observation preserved through the training
minibatchlist = [np.array(sorted(indices[start_idx:start_idx + self.batch_size]))
for start_idx in range(0, len(indices) - self.batch_size + 1, self.batch_size)]
data_loader = DataLoader(minibatchlist, images_path, self.img_shape, n_workers=N_WORKERS, multi_view=False,
use_triplets=False, is_training=True,absolute_path=False)
test_minibatchlist = DataLoader.createTestMinibatchList(len(images_path), MAX_BATCH_SIZE_GPU)
test_data_loader = DataLoader(test_minibatchlist, images_path, self.img_shape, n_workers=N_WORKERS, multi_view=False,
use_triplets=False, max_queue_len=1, is_training=False,absolute_path=False)
# Number of minibatches used for validation:
n_val_batches = np.round(VALIDATION_SIZE * len(minibatchlist)).astype(np.int64)
val_indices = np.random.permutation(len(minibatchlist))[:n_val_batches]
# Print some info
print("{} minibatches for training, {} samples".format(len(minibatchlist) - n_val_batches,
(len(minibatchlist) - n_val_batches) * BATCH_SIZE))
print("{} minibatches for validation, {} samples".format(n_val_batches, n_val_batches * BATCH_SIZE))
assert n_val_batches > 0, "Not enough sample to create a validation set"
# Stats about actions
if not args.continuous_actions:
print('Discrete action space:')
action_set = set(actions)
n_actions = int(np.max(actions) + 1)
print("{} unique actions / {} actions".format(len(action_set), n_actions))
n_obs_per_action = np.zeros(n_actions, dtype=np.int64)
for i in range(n_actions):
n_obs_per_action[i] = np.sum(actions == i)
print("Number of observations per action")
print(n_obs_per_action)
else:
print('Continuous action space:')
print('Action dimension: {}'.format(self.dim_action))
# Here the default SRL model is assumed to be raw_pixels
self.state_dim = self.img_shape[0] * self.img_shape[1] * self.img_shape[2] # why
self.srl_model = None
print("env_kwargs[srl_model] ",env_kwargs["srl_model"])
# TODO: add sanity checks & test for all possible SRL for distillation
if env_kwargs["srl_model"] == "raw_pixels":
# if the pilicy distillation is used with raw pixel
self.model = CNNPolicy(n_actions, self.img_shape)
learnable_params = self.model.parameters()
learning_rate = 1e-3
else:
self.state_dim = getSRLDim(env_kwargs.get("srl_model_path", None))
self.srl_model = loadSRLModel(env_kwargs.get("srl_model_path", None),
th.cuda.is_available(), self.state_dim, env_object=None)
self.model = MLPPolicy(output_size=n_actions, input_size=self.state_dim)
for param in self.model.parameters():
param.requires_grad = True
learnable_params = [param for param in self.model.parameters()]
if FINE_TUNING and self.srl_model is not None:
for param in self.srl_model.model.parameters(): | param.requires_grad = True
learnable_params += [param for param in self.srl_model.model.parameters()]
learning_rate = 1e-3 | random_line_split | |
policy_distillation.py | _size, self.hidden_size),
nn.ReLU(inplace=True),
nn.Linear(self.hidden_size, self.output_size)
)
def forward(self, input):
input = input.view(-1, self.input_size)
return F.softmax(self.fc(input), dim=1)
class CNNPolicy(nn.Module):
def __init__(self, output_size, img_shape):
super(CNNPolicy, self).__init__()
self.model = CustomCNN(state_dim=output_size, img_shape=img_shape)
def forward(self, input):
return F.softmax(self.model(input), dim=1)
class PolicyDistillationModel(BaseRLObject):
"""
Implementation of PolicyDistillation
"""
def __init__(self):
super(PolicyDistillationModel, self).__init__()
def save(self, save_path, _locals=None):
assert self.model is not None, "Error: must train or load model before use"
with open(save_path, "wb") as f:
pickle.dump(self.__dict__, f)
@classmethod
def load(cls, load_path, args=None):
with open(load_path, "rb") as f:
class_dict = pickle.load(f)
loaded_model = PolicyDistillationModel()
loaded_model.__dict__ = class_dict
return loaded_model
def customArguments(self, parser):
|
def getActionProba(self, observation, dones=None, delta=0):
"""
returns the action probability distribution, from a given observation.
:param observation: (numpy int or numpy float)
:param dones: ([bool])
:param delta: (numpy float or float) The exploration noise applied to the policy, set to 0 for no noise.
:return: (numpy float)
"""
assert self.model is not None, "Error: must train or load model before use"
if len(observation.shape) > 2:
observation = np.transpose(observation, (0, 3, 2, 1))
observation = th.from_numpy(observation).float().requires_grad_(False).to(self.device)
action = self.model.forward(observation).detach().cpu().numpy()
return action
def getAction(self, observation, dones=None, delta=0, sample=False):
"""
From an observation returns the associated action
:param observation: (numpy int or numpy float)
:param dones: ([bool])
:param delta: (numpy float or float) The exploration noise applied to the policy, set to 0 for no noise.
:return: (numpy float)
"""
assert self.model is not None, "Error: must train or load model before use"
self.model.eval()
if len(observation.shape) > 2:
observation = np.transpose(observation, (0, 3, 2, 1))
observation = th.from_numpy(observation).float().requires_grad_(False).to(self.device)
if sample:
proba_actions = self.model.forward(observation).detach().cpu().numpy().flatten()
return np.random.choice(range(len(proba_actions)), 1, p=proba_actions)
else:
return [np.argmax(self.model.forward(observation).detach().cpu().numpy())]
def loss_fn_kd(self, outputs, teacher_outputs, labels=None, adaptive_temperature=False):
"""
Hyperparameters: temperature and alpha
:param outputs: output from the student model
:param teacher_outputs: output from the teacher_outputs model
:return: loss
"""
if labels is not None and adaptive_temperature:
T = th.from_numpy(np.array([TEMPERATURES[labels[idx_elm]] for idx_elm in range(BATCH_SIZE)])).cuda().float()
KD_loss = F.softmax(th.div(teacher_outputs.transpose(1, 0), T), dim=1) * \
th.log((F.softmax(th.div(teacher_outputs.transpose(1, 0), T), dim=1) / F.softmax(outputs.transpose(1,0), dim=1)))
else:
T = TEMPERATURES["default"]
print('1',teacher_outputs.size())
print('2', outputs.size())
KD_loss = F.softmax(teacher_outputs/T, dim=1) * \
th.log((F.softmax(teacher_outputs/T, dim=1) / F.softmax(outputs, dim=1)))
print(KD_loss.size())
return KD_loss.mean()
def loss_mse(self, outputs, teacher_outputs):
return (outputs - teacher_outputs).pow(2).sum(1).mean()
def train(self, args, callback, env_kwargs=None, train_kwargs=None):
N_EPOCHS = args.epochs_distillation
self.seed = args.seed
self.batch_size = BATCH_SIZE
print("We assumed SRL training already done")
print('Loading data for distillation ')
# training_data, ground_truth, true_states, _ = loadData(args.teacher_data_folder)
training_data, ground_truth, _, _ = loadData(args.teacher_data_folder, with_env=False)
images_path = ground_truth['images_path']
episode_starts = training_data['episode_starts']
actions = training_data['actions']
actions_proba = training_data['actions_proba']
if USE_ADAPTIVE_TEMPERATURE:
cl_labels = training_data[CL_LABEL_KEY]
else:
cl_labels_st = None
if args.distillation_training_set_size > 0:
limit = args.distillation_training_set_size
actions = actions[:limit]
images_path = images_path[:limit]
episode_starts = episode_starts[:limit]
images_path_copy = [images_path[k] for k in range(images_path.shape[0])]
images_path = np.array(images_path_copy)
num_samples = images_path.shape[0] - 1 # number of samples
if args.img_shape is None:
self.img_shape = None #(3,224,224)
else:
self.img_shape = tuple(map(int, args.img_shape[1:-1].split(",")))
# indices for all time steps where the episode continues
indices = np.array([i for i in range(num_samples) if not episode_starts[i + 1]], dtype='int64')
np.random.shuffle(indices)
# split indices into minibatches. minibatchlist is a list of lists; each
# list is the id of the observation preserved through the training
minibatchlist = [np.array(sorted(indices[start_idx:start_idx + self.batch_size]))
for start_idx in range(0, len(indices) - self.batch_size + 1, self.batch_size)]
data_loader = DataLoader(minibatchlist, images_path, self.img_shape, n_workers=N_WORKERS, multi_view=False,
use_triplets=False, is_training=True,absolute_path=False)
test_minibatchlist = DataLoader.createTestMinibatchList(len(images_path), MAX_BATCH_SIZE_GPU)
test_data_loader = DataLoader(test_minibatchlist, images_path, self.img_shape, n_workers=N_WORKERS, multi_view=False,
use_triplets=False, max_queue_len=1, is_training=False,absolute_path=False)
# Number of minibatches used for validation:
n_val_batches = np.round(VALIDATION_SIZE * len(minibatchlist)).astype(np.int64)
val_indices = np.random.permutation(len(minibatchlist))[:n_val_batches]
# Print some info
print("{} minibatches for training, {} samples".format(len(minibatchlist) - n_val_batches,
(len(minibatchlist) - n_val_batches) * BATCH_SIZE))
print("{} minibatches for validation, {} samples".format(n_val_batches, n_val_batches * BATCH_SIZE))
assert n_val_batches > 0, "Not enough sample to create a validation set"
# Stats about actions
if not args.continuous_actions:
print('Discrete action space:')
action_set = set(actions)
n_actions = int(np.max(actions) + 1)
print("{} unique actions / {} actions".format(len(action_set), n_actions))
n_obs_per_action = np.zeros(n_actions, dtype=np.int64)
for i in range(n_actions):
n_obs_per_action[i] = np.sum(actions == i)
print("Number of observations per action")
print(n_obs_per_action)
else:
print('Continuous action space:')
print('Action dimension: {}'.format(self.dim_action))
# Here the default SRL model is assumed to be raw_pixels
self.state_dim = self.img_shape[0] * self.img_shape[1] * self.img_shape[2] # why
self.srl_model = None
print("env_kwargs[srl_model] ",env_kwargs["srl_model"])
# TODO: add sanity checks & test for all possible SRL for distillation
if env_kwargs["srl_model"] == "raw_pixels":
# if the pilicy distillation is used with raw pixel
self.model = CNNPolicy(n_actions, self.img_shape)
learnable_params = self.model.parameters()
learning_rate = 1e-3
else:
self.state_dim = getSRLDim(env_kwargs.get("srl_model_path", None))
self.srl_model = loadSRLModel(env_kwargs.get("srl_model_path", None),
th.cuda.is_available(), self.state_dim, env_object=None)
self.model = MLPPolicy(output_size=n_actions | parser.add_argument('--nothing4instance', help='Number of population (each one has 2 threads)', type=bool,
default=True)
return parser | identifier_body |
policy_distillation.py | _size, self.hidden_size),
nn.ReLU(inplace=True),
nn.Linear(self.hidden_size, self.output_size)
)
def forward(self, input):
input = input.view(-1, self.input_size)
return F.softmax(self.fc(input), dim=1)
class CNNPolicy(nn.Module):
def __init__(self, output_size, img_shape):
super(CNNPolicy, self).__init__()
self.model = CustomCNN(state_dim=output_size, img_shape=img_shape)
def forward(self, input):
return F.softmax(self.model(input), dim=1)
class PolicyDistillationModel(BaseRLObject):
"""
Implementation of PolicyDistillation
"""
def __init__(self):
super(PolicyDistillationModel, self).__init__()
def save(self, save_path, _locals=None):
assert self.model is not None, "Error: must train or load model before use"
with open(save_path, "wb") as f:
pickle.dump(self.__dict__, f)
@classmethod
def load(cls, load_path, args=None):
with open(load_path, "rb") as f:
class_dict = pickle.load(f)
loaded_model = PolicyDistillationModel()
loaded_model.__dict__ = class_dict
return loaded_model
def customArguments(self, parser):
parser.add_argument('--nothing4instance', help='Number of population (each one has 2 threads)', type=bool,
default=True)
return parser
def getActionProba(self, observation, dones=None, delta=0):
"""
returns the action probability distribution, from a given observation.
:param observation: (numpy int or numpy float)
:param dones: ([bool])
:param delta: (numpy float or float) The exploration noise applied to the policy, set to 0 for no noise.
:return: (numpy float)
"""
assert self.model is not None, "Error: must train or load model before use"
if len(observation.shape) > 2:
observation = np.transpose(observation, (0, 3, 2, 1))
observation = th.from_numpy(observation).float().requires_grad_(False).to(self.device)
action = self.model.forward(observation).detach().cpu().numpy()
return action
def getAction(self, observation, dones=None, delta=0, sample=False):
"""
From an observation returns the associated action
:param observation: (numpy int or numpy float)
:param dones: ([bool])
:param delta: (numpy float or float) The exploration noise applied to the policy, set to 0 for no noise.
:return: (numpy float)
"""
assert self.model is not None, "Error: must train or load model before use"
self.model.eval()
if len(observation.shape) > 2:
|
observation = th.from_numpy(observation).float().requires_grad_(False).to(self.device)
if sample:
proba_actions = self.model.forward(observation).detach().cpu().numpy().flatten()
return np.random.choice(range(len(proba_actions)), 1, p=proba_actions)
else:
return [np.argmax(self.model.forward(observation).detach().cpu().numpy())]
def loss_fn_kd(self, outputs, teacher_outputs, labels=None, adaptive_temperature=False):
"""
Hyperparameters: temperature and alpha
:param outputs: output from the student model
:param teacher_outputs: output from the teacher_outputs model
:return: loss
"""
if labels is not None and adaptive_temperature:
T = th.from_numpy(np.array([TEMPERATURES[labels[idx_elm]] for idx_elm in range(BATCH_SIZE)])).cuda().float()
KD_loss = F.softmax(th.div(teacher_outputs.transpose(1, 0), T), dim=1) * \
th.log((F.softmax(th.div(teacher_outputs.transpose(1, 0), T), dim=1) / F.softmax(outputs.transpose(1,0), dim=1)))
else:
T = TEMPERATURES["default"]
print('1',teacher_outputs.size())
print('2', outputs.size())
KD_loss = F.softmax(teacher_outputs/T, dim=1) * \
th.log((F.softmax(teacher_outputs/T, dim=1) / F.softmax(outputs, dim=1)))
print(KD_loss.size())
return KD_loss.mean()
def loss_mse(self, outputs, teacher_outputs):
return (outputs - teacher_outputs).pow(2).sum(1).mean()
def train(self, args, callback, env_kwargs=None, train_kwargs=None):
N_EPOCHS = args.epochs_distillation
self.seed = args.seed
self.batch_size = BATCH_SIZE
print("We assumed SRL training already done")
print('Loading data for distillation ')
# training_data, ground_truth, true_states, _ = loadData(args.teacher_data_folder)
training_data, ground_truth, _, _ = loadData(args.teacher_data_folder, with_env=False)
images_path = ground_truth['images_path']
episode_starts = training_data['episode_starts']
actions = training_data['actions']
actions_proba = training_data['actions_proba']
if USE_ADAPTIVE_TEMPERATURE:
cl_labels = training_data[CL_LABEL_KEY]
else:
cl_labels_st = None
if args.distillation_training_set_size > 0:
limit = args.distillation_training_set_size
actions = actions[:limit]
images_path = images_path[:limit]
episode_starts = episode_starts[:limit]
images_path_copy = [images_path[k] for k in range(images_path.shape[0])]
images_path = np.array(images_path_copy)
num_samples = images_path.shape[0] - 1 # number of samples
if args.img_shape is None:
self.img_shape = None #(3,224,224)
else:
self.img_shape = tuple(map(int, args.img_shape[1:-1].split(",")))
# indices for all time steps where the episode continues
indices = np.array([i for i in range(num_samples) if not episode_starts[i + 1]], dtype='int64')
np.random.shuffle(indices)
# split indices into minibatches. minibatchlist is a list of lists; each
# list is the id of the observation preserved through the training
minibatchlist = [np.array(sorted(indices[start_idx:start_idx + self.batch_size]))
for start_idx in range(0, len(indices) - self.batch_size + 1, self.batch_size)]
data_loader = DataLoader(minibatchlist, images_path, self.img_shape, n_workers=N_WORKERS, multi_view=False,
use_triplets=False, is_training=True,absolute_path=False)
test_minibatchlist = DataLoader.createTestMinibatchList(len(images_path), MAX_BATCH_SIZE_GPU)
test_data_loader = DataLoader(test_minibatchlist, images_path, self.img_shape, n_workers=N_WORKERS, multi_view=False,
use_triplets=False, max_queue_len=1, is_training=False,absolute_path=False)
# Number of minibatches used for validation:
n_val_batches = np.round(VALIDATION_SIZE * len(minibatchlist)).astype(np.int64)
val_indices = np.random.permutation(len(minibatchlist))[:n_val_batches]
# Print some info
print("{} minibatches for training, {} samples".format(len(minibatchlist) - n_val_batches,
(len(minibatchlist) - n_val_batches) * BATCH_SIZE))
print("{} minibatches for validation, {} samples".format(n_val_batches, n_val_batches * BATCH_SIZE))
assert n_val_batches > 0, "Not enough sample to create a validation set"
# Stats about actions
if not args.continuous_actions:
print('Discrete action space:')
action_set = set(actions)
n_actions = int(np.max(actions) + 1)
print("{} unique actions / {} actions".format(len(action_set), n_actions))
n_obs_per_action = np.zeros(n_actions, dtype=np.int64)
for i in range(n_actions):
n_obs_per_action[i] = np.sum(actions == i)
print("Number of observations per action")
print(n_obs_per_action)
else:
print('Continuous action space:')
print('Action dimension: {}'.format(self.dim_action))
# Here the default SRL model is assumed to be raw_pixels
self.state_dim = self.img_shape[0] * self.img_shape[1] * self.img_shape[2] # why
self.srl_model = None
print("env_kwargs[srl_model] ",env_kwargs["srl_model"])
# TODO: add sanity checks & test for all possible SRL for distillation
if env_kwargs["srl_model"] == "raw_pixels":
# if the pilicy distillation is used with raw pixel
self.model = CNNPolicy(n_actions, self.img_shape)
learnable_params = self.model.parameters()
learning_rate = 1e-3
else:
self.state_dim = getSRLDim(env_kwargs.get("srl_model_path", None))
self.srl_model = loadSRLModel(env_kwargs.get("srl_model_path", None),
th.cuda.is_available(), self.state_dim, env_object=None)
self.model = MLPPolicy(output_size=n | observation = np.transpose(observation, (0, 3, 2, 1)) | conditional_block |
WarpController.ts | Name: 'InitialReporterRedeemed' },
{ databaseName: 'InitialReportSubmitted' },
{ databaseName: 'InitialReporterTransferred' },
{ databaseName: 'MarketCreated' },
{ databaseName: 'MarketFinalized' },
{ databaseName: 'MarketMigrated' },
{ databaseName: 'MarketParticipantsDisavowed' },
{ databaseName: 'MarketTransferred' },
{ databaseName: 'MarketVolumeChanged' },
{ databaseName: 'MarketOIChanged' },
{ databaseName: 'OrderEvent' },
{ databaseName: 'ParticipationTokensRedeemed' },
{ databaseName: 'ProfitLossChanged' },
{ databaseName: 'ReportingParticipantDisavowed' },
{ databaseName: 'TimestampSet' },
{ databaseName: 'TokenBalanceChanged' },
{ databaseName: 'TokensMinted' },
{ databaseName: 'TokensTransferred' },
{ databaseName: 'TradingProceedsClaimed' },
{ databaseName: 'UniverseCreated' },
{ databaseName: 'UniverseForked' },
{ databaseName: 'TransferSingle' },
{ databaseName: 'TransferBatch' },
{ databaseName: 'ShareTokenBalanceChanged' },
];
export interface CheckpointInterface {
startBlockNumber: number;
endBlockNumber: number;
logs: SerializedLog[];
}
export class WarpController {
private static DEFAULT_NODE_TYPE = { format: 'dag-pb', hashAlg: 'sha2-256' };
checkpoints: Checkpoints;
ipfs: Promise<IPFS>;
constructor(
private db: DB,
private augur: Augur<Provider>,
private provider: Provider,
private uploadBlockNumber: number,
private ipfsEndpointInfo:IPFSEndpointInfo,
ipfs?: Promise<IPFS>,
) {
this.checkpoints = new Checkpoints(provider);
if (ipfs) {
this.ipfs = ipfs;
} else {
this.ipfs = IPFS.create({
repo: './data',
});
}
}
async getIpfs(): Promise<IPFS> {
return this.ipfs;
}
onNewBlock = async (newBlock: Block): Promise<string | void> => {
await this.createInitialCheckpoint();
/*
0. Base case: need to have created initial warp checkpoint.
1. Check if we need to create warp sync
1. This will happen if the active market endTime has elapsed
2. Check if we have a market awaiting finalization
1. If so, do we dispute?
3. If market is finalized
1. If no dispute we make note of new market end time
*/
const mostRecentCheckpoint = await this.db.warpCheckpoints.getMostRecentCheckpoint();
// Universe not initialized.
if (!mostRecentCheckpoint) {
return;
}
// Warp sync has been created. Need to report, dispute or create next unfinished checkpoint record.
if (mostRecentCheckpoint.end) {
const [marketRecord] = await Markets.getMarketsInfo(this.augur, this.db, {
marketIds: [mostRecentCheckpoint.market],
});
switch (marketRecord.reportingState) {
case MarketReportingState.OpenReporting:
// Emit event to notify UI to report.
break;
case MarketReportingState.AwaitingFinalization:
// confirm hash matches and emit dispute event if needed.
break;
case MarketReportingState.Finalized:
const endBlock = Object.assign({}, mostRecentCheckpoint.end, {
gasLimit: new BigNumber(mostRecentCheckpoint.end.gasLimit),
gasUsed: new BigNumber(mostRecentCheckpoint.end.gasUsed),
})
const [begin, end] = await this.checkpoints.calculateBoundary(
mostRecentCheckpoint.endTimestamp,
endBlock
);
const newWarpSyncMarket = await this.augur.warpSync.getWarpSyncMarket(
this.augur.contracts.universe.address
);
await this.db.warpCheckpoints.createInitialCheckpoint(
end,
newWarpSyncMarket
);
break;
default:
}
return;
}
// WarpSync Market has ended. Need to create checkpoint.
if (mostRecentCheckpoint.endTimestamp < newBlock.timestamp) {
const [
newEndBlock,
newBeginBlock,
] = await this.checkpoints.calculateBoundary(
mostRecentCheckpoint.endTimestamp,
await this.provider.getBlock(this.uploadBlockNumber),
newBlock
);
// Market has finished and now we need to wait 30 blocks.
if (newBlock.number - newEndBlock.number < 30) return;
await this.db.prune(newEndBlock.timestamp);
// This version of the client will no longer generate a
// warp sync because it does not know about the para deploy logs.
}
// nothing left to do.
};
async createInitialCheckpoint() {
const mostRecentCheckpoint = await this.db.warpCheckpoints.getMostRecentCheckpoint();
if (!mostRecentCheckpoint) {
const market = await this.augur.warpSync.getWarpSyncMarket(
this.augur.contracts.universe.address
);
if (market.address === NULL_ADDRESS) {
console.log(
`Warp sync market not initialized for current universe ${this.augur.contracts.universe.address}.`
);
return;
}
await this.db.warpCheckpoints.createInitialCheckpoint(
await this.provider.getBlock(this.uploadBlockNumber),
market
);
}
}
async destroyAndRecreateDB() {
await this.db.delete();
await this.db.initializeDB();
}
async createCheckpoint(endBlock: Block): Promise<IpfsInfo> {
const logs = [];
for (const { databaseName } of databasesToSync) {
// Awaiting here to reduce load on db.
logs.push(
await this.db[databaseName]
.where('blockNumber')
.between(this.uploadBlockNumber, endBlock.number, true, true)
.toArray()
);
}
const sortedLogs = _.orderBy(
_.flatten(logs),
['blockNumber', 'logIndex'],
['asc', 'asc']
);
const body = JSON.stringify({
startBlockNumber: this.uploadBlockNumber,
endBlockNumber: endBlock.number,
logs: sortedLogs,
} as CheckpointInterface);
const content = LZString.compressToUint8Array(body);
const [result] = await (await this.ipfs).add({
content,
});
const topLevelDirectory = new DAGNode(
Unixfs.default('directory').marshal()
);
const versionFile = await (await this.ipfs).add({
content: Buffer.from(WARPSYNC_VERSION),
});
topLevelDirectory.addLink({
Name: 'VERSION',
Hash: versionFile[0].hash,
Size: 1,
});
topLevelDirectory.addLink({
Name: 'index',
Hash: result.hash,
Size: 0,
});
const hash = (await (await this.ipfs).dag.put(
topLevelDirectory,
WarpController.DEFAULT_NODE_TYPE
)).toString();
await this.db.warpCheckpoints.createCheckpoint(endBlock, hash);
return hash;
}
getFile(ipfsHash: string, ipfsPath: string) {
return new Promise<CheckpointInterface>(async (resolve, reject) => {
const timeout = setTimeout(() => {reject(new Error('Request timed out'));}, FILE_FETCH_TIMEOUT);
let fileResult;
switch (this.ipfsEndpointInfo.version) {
case IPFSHashVersion.CIDv0:
case IPFSHashVersion.CIDv1:
fileResult = await fetch(`${this.ipfsEndpointInfo.url}/${ipfsHash}${ipfsPath}`)
.then(item => item.arrayBuffer())
.then(item => new Uint8Array(item))
break;
case IPFSHashVersion.IPFS:
try {
fileResult = await (await this.ipfs).cat(`${ipfsHash}${ipfsPath}`);
} catch(err) {
if (err.message === 'this dag node is a directory') {
throw Error(`IPFS: tried to read directory as if it were a file: hash=${ipfsHash} path=${ipfsPath}`)
}
}
break;
default:
throw new Error('No IPFS gateway configured');
}
clearTimeout(timeout);
const decompressedResult = await LZString.decompressFromUint8Array(fileResult);
resolve(JSON.parse(decompressedResult));
});
}
async getCheckpointFile(ipfsRootHash: string): Promise<CheckpointInterface> {
return this.getFile(ipfsRootHash, '/index');
}
async pinHashByGatewayUrl(urlString: string) {
const url = new URL(urlString);
try {
const matches = /^(\w+)\.ipfs\..+$/.exec(url.hostname);
const thingToPin = (matches) ? matches[1] : url.pathname;
await (await this.ipfs).pin.add(thingToPin);
logger.info(`Client pinned with ipfs hash: ${thingToPin}`)
return true;
} catch (e) {
return false;
}
}
async getMostRecentWarpSync() {
return this.db.warpCheckpoints.getMostRecentWarpSync();
}
async getMostRecentCheckpoint() | {
return this.db.warpCheckpoints.getMostRecentCheckpoint();
} | identifier_body | |
WarpController.ts | { Checkpoints } from './Checkpoints';
export const WARPSYNC_VERSION = '1';
const FILE_FETCH_TIMEOUT = 30000; // 10 seconds
type NameOfType<T, R> = {
[P in keyof T]: T[P] extends R ? P : never;
}[keyof T];
type AllDBNames = NameOfType<DB, Dexie.Table<Log, unknown>>;
type AllDbs = {
[P in AllDBNames]: DB[P] extends Dexie.Table<infer R, unknown> ? R : never;
};
// Assuming indexes we need are simple ones e.g. 'market'.
// Will need to rethink this for something like '[universe+reporter]'.
type DbExpander<P, G extends keyof AllDbs> = P extends keyof AllDbs
? {
databaseName: P;
indexes?: Readonly<Array<keyof AllDbs[P]>>;
join?: G extends keyof AllDbs
? Readonly<{
// Indexes to query source db on.
indexes: Readonly<Array<keyof AllDbs[G]>>;
// The common index between the two DBs.
// length 2 or more is treated
on: Readonly<Array<keyof AllDbs[P] & keyof AllDbs[G]>>;
// This is the source of the criteria to filter the `dataBaseName` db with.
source: G;
}>
: never;
}
: never;
type Db = DbExpander<keyof AllDbs, keyof AllDbs>;
export type RollupDescription = Readonly<Db[]>;
interface IPFSObject {
Hash: string;
Name?: string;
Size: number;
}
export const databasesToSync: RollupDescription = [
{ databaseName: 'CompleteSetsPurchased' },
{ databaseName: 'CompleteSetsSold' },
{ databaseName: 'DisputeCrowdsourcerContribution' },
{ databaseName: 'DisputeCrowdsourcerCompleted' },
{ databaseName: 'DisputeCrowdsourcerCreated' },
{ databaseName: 'DisputeCrowdsourcerRedeemed' },
{ databaseName: 'DisputeWindowCreated' },
{ databaseName: 'InitialReporterRedeemed' },
{ databaseName: 'InitialReportSubmitted' },
{ databaseName: 'InitialReporterTransferred' },
{ databaseName: 'MarketCreated' },
{ databaseName: 'MarketFinalized' },
{ databaseName: 'MarketMigrated' },
{ databaseName: 'MarketParticipantsDisavowed' },
{ databaseName: 'MarketTransferred' },
{ databaseName: 'MarketVolumeChanged' },
{ databaseName: 'MarketOIChanged' },
{ databaseName: 'OrderEvent' },
{ databaseName: 'ParticipationTokensRedeemed' },
{ databaseName: 'ProfitLossChanged' },
{ databaseName: 'ReportingParticipantDisavowed' },
{ databaseName: 'TimestampSet' },
{ databaseName: 'TokenBalanceChanged' },
{ databaseName: 'TokensMinted' },
{ databaseName: 'TokensTransferred' },
{ databaseName: 'TradingProceedsClaimed' },
{ databaseName: 'UniverseCreated' },
{ databaseName: 'UniverseForked' },
{ databaseName: 'TransferSingle' },
{ databaseName: 'TransferBatch' },
{ databaseName: 'ShareTokenBalanceChanged' },
];
export interface CheckpointInterface {
startBlockNumber: number;
endBlockNumber: number;
logs: SerializedLog[];
}
export class WarpController {
private static DEFAULT_NODE_TYPE = { format: 'dag-pb', hashAlg: 'sha2-256' };
checkpoints: Checkpoints;
ipfs: Promise<IPFS>;
constructor(
private db: DB,
private augur: Augur<Provider>,
private provider: Provider,
private uploadBlockNumber: number,
private ipfsEndpointInfo:IPFSEndpointInfo,
ipfs?: Promise<IPFS>,
) {
this.checkpoints = new Checkpoints(provider);
if (ipfs) {
this.ipfs = ipfs;
} else {
this.ipfs = IPFS.create({
repo: './data',
});
}
}
async getIpfs(): Promise<IPFS> {
return this.ipfs;
}
onNewBlock = async (newBlock: Block): Promise<string | void> => {
await this.createInitialCheckpoint();
/*
0. Base case: need to have created initial warp checkpoint.
1. Check if we need to create warp sync
1. This will happen if the active market endTime has elapsed
2. Check if we have a market awaiting finalization
1. If so, do we dispute?
3. If market is finalized
1. If no dispute we make note of new market end time
*/
const mostRecentCheckpoint = await this.db.warpCheckpoints.getMostRecentCheckpoint();
// Universe not initialized.
if (!mostRecentCheckpoint) {
return;
}
// Warp sync has been created. Need to report, dispute or create next unfinished checkpoint record.
if (mostRecentCheckpoint.end) {
const [marketRecord] = await Markets.getMarketsInfo(this.augur, this.db, {
marketIds: [mostRecentCheckpoint.market],
});
switch (marketRecord.reportingState) {
case MarketReportingState.OpenReporting:
// Emit event to notify UI to report.
break;
case MarketReportingState.AwaitingFinalization:
// confirm hash matches and emit dispute event if needed.
break;
case MarketReportingState.Finalized:
const endBlock = Object.assign({}, mostRecentCheckpoint.end, {
gasLimit: new BigNumber(mostRecentCheckpoint.end.gasLimit),
gasUsed: new BigNumber(mostRecentCheckpoint.end.gasUsed),
})
const [begin, end] = await this.checkpoints.calculateBoundary(
mostRecentCheckpoint.endTimestamp,
endBlock
);
const newWarpSyncMarket = await this.augur.warpSync.getWarpSyncMarket(
this.augur.contracts.universe.address
);
await this.db.warpCheckpoints.createInitialCheckpoint(
end,
newWarpSyncMarket
);
break;
default:
}
return;
}
// WarpSync Market has ended. Need to create checkpoint.
if (mostRecentCheckpoint.endTimestamp < newBlock.timestamp) {
const [
newEndBlock,
newBeginBlock,
] = await this.checkpoints.calculateBoundary(
mostRecentCheckpoint.endTimestamp,
await this.provider.getBlock(this.uploadBlockNumber),
newBlock
);
// Market has finished and now we need to wait 30 blocks.
if (newBlock.number - newEndBlock.number < 30) return;
await this.db.prune(newEndBlock.timestamp);
// This version of the client will no longer generate a
// warp sync because it does not know about the para deploy logs.
}
// nothing left to do.
};
async createInitialCheckpoint() {
const mostRecentCheckpoint = await this.db.warpCheckpoints.getMostRecentCheckpoint();
if (!mostRecentCheckpoint) {
const market = await this.augur.warpSync.getWarpSyncMarket(
this.augur.contracts.universe.address
);
if (market.address === NULL_ADDRESS) |
await this.db.warpCheckpoints.createInitialCheckpoint(
await this.provider.getBlock(this.uploadBlockNumber),
market
);
}
}
async destroyAndRecreateDB() {
await this.db.delete();
await this.db.initializeDB();
}
async createCheckpoint(endBlock: Block): Promise<IpfsInfo> {
const logs = [];
for (const { databaseName } of databasesToSync) {
// Awaiting here to reduce load on db.
logs.push(
await this.db[databaseName]
.where('blockNumber')
.between(this.uploadBlockNumber, endBlock.number, true, true)
.toArray()
);
}
const sortedLogs = _.orderBy(
_.flatten(logs),
['blockNumber', 'logIndex'],
['asc', 'asc']
);
const body = JSON.stringify({
startBlockNumber: this.uploadBlockNumber,
endBlockNumber: endBlock.number,
logs: sortedLogs,
} as CheckpointInterface);
const content = LZString.compressToUint8Array(body);
const [result] = await (await this.ipfs).add({
content,
});
const topLevelDirectory = new DAGNode(
Unixfs.default('directory').marshal()
);
const versionFile = await (await this.ipfs).add({
content: Buffer.from(WARPSYNC_VERSION),
});
topLevelDirectory.addLink({
Name: 'VERSION',
Hash: versionFile[0].hash,
Size: 1,
});
topLevelDirectory.addLink({
Name: 'index',
Hash: result.hash,
Size: 0,
});
const hash = (await (await this.ipfs).dag.put(
topLevelDirectory,
WarpController.DEFAULT_NODE_TYPE
)).toString();
await this.db.warpCheckpoints.createCheckpoint(endBlock, hash);
return | {
console.log(
`Warp sync market not initialized for current universe ${this.augur.contracts.universe.address}.`
);
return;
} | conditional_block |
WarpController.ts | { Checkpoints } from './Checkpoints';
export const WARPSYNC_VERSION = '1';
const FILE_FETCH_TIMEOUT = 30000; // 10 seconds
type NameOfType<T, R> = {
[P in keyof T]: T[P] extends R ? P : never;
}[keyof T];
type AllDBNames = NameOfType<DB, Dexie.Table<Log, unknown>>;
type AllDbs = {
[P in AllDBNames]: DB[P] extends Dexie.Table<infer R, unknown> ? R : never;
};
// Assuming indexes we need are simple ones e.g. 'market'.
// Will need to rethink this for something like '[universe+reporter]'.
type DbExpander<P, G extends keyof AllDbs> = P extends keyof AllDbs
? {
databaseName: P;
indexes?: Readonly<Array<keyof AllDbs[P]>>;
join?: G extends keyof AllDbs
? Readonly<{
// Indexes to query source db on.
indexes: Readonly<Array<keyof AllDbs[G]>>;
// The common index between the two DBs.
// length 2 or more is treated
on: Readonly<Array<keyof AllDbs[P] & keyof AllDbs[G]>>;
// This is the source of the criteria to filter the `dataBaseName` db with.
source: G;
}>
: never;
}
: never;
type Db = DbExpander<keyof AllDbs, keyof AllDbs>;
export type RollupDescription = Readonly<Db[]>;
interface IPFSObject {
Hash: string;
Name?: string;
Size: number;
}
export const databasesToSync: RollupDescription = [
{ databaseName: 'CompleteSetsPurchased' },
{ databaseName: 'CompleteSetsSold' },
{ databaseName: 'DisputeCrowdsourcerContribution' },
{ databaseName: 'DisputeCrowdsourcerCompleted' },
{ databaseName: 'DisputeCrowdsourcerCreated' },
{ databaseName: 'DisputeCrowdsourcerRedeemed' },
{ databaseName: 'DisputeWindowCreated' },
{ databaseName: 'InitialReporterRedeemed' },
{ databaseName: 'InitialReportSubmitted' },
{ databaseName: 'InitialReporterTransferred' },
{ databaseName: 'MarketCreated' },
{ databaseName: 'MarketFinalized' },
{ databaseName: 'MarketMigrated' },
{ databaseName: 'MarketParticipantsDisavowed' },
{ databaseName: 'MarketTransferred' },
{ databaseName: 'MarketVolumeChanged' },
{ databaseName: 'MarketOIChanged' },
{ databaseName: 'OrderEvent' },
{ databaseName: 'ParticipationTokensRedeemed' },
{ databaseName: 'ProfitLossChanged' },
{ databaseName: 'ReportingParticipantDisavowed' },
{ databaseName: 'TimestampSet' },
{ databaseName: 'TokenBalanceChanged' },
{ databaseName: 'TokensMinted' },
{ databaseName: 'TokensTransferred' },
{ databaseName: 'TradingProceedsClaimed' },
{ databaseName: 'UniverseCreated' },
{ databaseName: 'UniverseForked' },
{ databaseName: 'TransferSingle' },
{ databaseName: 'TransferBatch' },
{ databaseName: 'ShareTokenBalanceChanged' },
];
export interface CheckpointInterface {
startBlockNumber: number;
endBlockNumber: number;
logs: SerializedLog[];
}
export class WarpController {
private static DEFAULT_NODE_TYPE = { format: 'dag-pb', hashAlg: 'sha2-256' };
checkpoints: Checkpoints;
ipfs: Promise<IPFS>;
constructor(
private db: DB,
private augur: Augur<Provider>,
private provider: Provider,
private uploadBlockNumber: number,
private ipfsEndpointInfo:IPFSEndpointInfo,
ipfs?: Promise<IPFS>,
) {
this.checkpoints = new Checkpoints(provider);
if (ipfs) {
this.ipfs = ipfs;
} else {
this.ipfs = IPFS.create({
repo: './data',
});
}
} | }
onNewBlock = async (newBlock: Block): Promise<string | void> => {
await this.createInitialCheckpoint();
/*
0. Base case: need to have created initial warp checkpoint.
1. Check if we need to create warp sync
1. This will happen if the active market endTime has elapsed
2. Check if we have a market awaiting finalization
1. If so, do we dispute?
3. If market is finalized
1. If no dispute we make note of new market end time
*/
const mostRecentCheckpoint = await this.db.warpCheckpoints.getMostRecentCheckpoint();
// Universe not initialized.
if (!mostRecentCheckpoint) {
return;
}
// Warp sync has been created. Need to report, dispute or create next unfinished checkpoint record.
if (mostRecentCheckpoint.end) {
const [marketRecord] = await Markets.getMarketsInfo(this.augur, this.db, {
marketIds: [mostRecentCheckpoint.market],
});
switch (marketRecord.reportingState) {
case MarketReportingState.OpenReporting:
// Emit event to notify UI to report.
break;
case MarketReportingState.AwaitingFinalization:
// confirm hash matches and emit dispute event if needed.
break;
case MarketReportingState.Finalized:
const endBlock = Object.assign({}, mostRecentCheckpoint.end, {
gasLimit: new BigNumber(mostRecentCheckpoint.end.gasLimit),
gasUsed: new BigNumber(mostRecentCheckpoint.end.gasUsed),
})
const [begin, end] = await this.checkpoints.calculateBoundary(
mostRecentCheckpoint.endTimestamp,
endBlock
);
const newWarpSyncMarket = await this.augur.warpSync.getWarpSyncMarket(
this.augur.contracts.universe.address
);
await this.db.warpCheckpoints.createInitialCheckpoint(
end,
newWarpSyncMarket
);
break;
default:
}
return;
}
// WarpSync Market has ended. Need to create checkpoint.
if (mostRecentCheckpoint.endTimestamp < newBlock.timestamp) {
const [
newEndBlock,
newBeginBlock,
] = await this.checkpoints.calculateBoundary(
mostRecentCheckpoint.endTimestamp,
await this.provider.getBlock(this.uploadBlockNumber),
newBlock
);
// Market has finished and now we need to wait 30 blocks.
if (newBlock.number - newEndBlock.number < 30) return;
await this.db.prune(newEndBlock.timestamp);
// This version of the client will no longer generate a
// warp sync because it does not know about the para deploy logs.
}
// nothing left to do.
};
async createInitialCheckpoint() {
const mostRecentCheckpoint = await this.db.warpCheckpoints.getMostRecentCheckpoint();
if (!mostRecentCheckpoint) {
const market = await this.augur.warpSync.getWarpSyncMarket(
this.augur.contracts.universe.address
);
if (market.address === NULL_ADDRESS) {
console.log(
`Warp sync market not initialized for current universe ${this.augur.contracts.universe.address}.`
);
return;
}
await this.db.warpCheckpoints.createInitialCheckpoint(
await this.provider.getBlock(this.uploadBlockNumber),
market
);
}
}
async destroyAndRecreateDB() {
await this.db.delete();
await this.db.initializeDB();
}
async createCheckpoint(endBlock: Block): Promise<IpfsInfo> {
const logs = [];
for (const { databaseName } of databasesToSync) {
// Awaiting here to reduce load on db.
logs.push(
await this.db[databaseName]
.where('blockNumber')
.between(this.uploadBlockNumber, endBlock.number, true, true)
.toArray()
);
}
const sortedLogs = _.orderBy(
_.flatten(logs),
['blockNumber', 'logIndex'],
['asc', 'asc']
);
const body = JSON.stringify({
startBlockNumber: this.uploadBlockNumber,
endBlockNumber: endBlock.number,
logs: sortedLogs,
} as CheckpointInterface);
const content = LZString.compressToUint8Array(body);
const [result] = await (await this.ipfs).add({
content,
});
const topLevelDirectory = new DAGNode(
Unixfs.default('directory').marshal()
);
const versionFile = await (await this.ipfs).add({
content: Buffer.from(WARPSYNC_VERSION),
});
topLevelDirectory.addLink({
Name: 'VERSION',
Hash: versionFile[0].hash,
Size: 1,
});
topLevelDirectory.addLink({
Name: 'index',
Hash: result.hash,
Size: 0,
});
const hash = (await (await this.ipfs).dag.put(
topLevelDirectory,
WarpController.DEFAULT_NODE_TYPE
)).toString();
await this.db.warpCheckpoints.createCheckpoint(endBlock, hash);
return hash |
async getIpfs(): Promise<IPFS> {
return this.ipfs; | random_line_split |
WarpController.ts | { Checkpoints } from './Checkpoints';
export const WARPSYNC_VERSION = '1';
const FILE_FETCH_TIMEOUT = 30000; // 10 seconds
type NameOfType<T, R> = {
[P in keyof T]: T[P] extends R ? P : never;
}[keyof T];
type AllDBNames = NameOfType<DB, Dexie.Table<Log, unknown>>;
type AllDbs = {
[P in AllDBNames]: DB[P] extends Dexie.Table<infer R, unknown> ? R : never;
};
// Assuming indexes we need are simple ones e.g. 'market'.
// Will need to rethink this for something like '[universe+reporter]'.
type DbExpander<P, G extends keyof AllDbs> = P extends keyof AllDbs
? {
databaseName: P;
indexes?: Readonly<Array<keyof AllDbs[P]>>;
join?: G extends keyof AllDbs
? Readonly<{
// Indexes to query source db on.
indexes: Readonly<Array<keyof AllDbs[G]>>;
// The common index between the two DBs.
// length 2 or more is treated
on: Readonly<Array<keyof AllDbs[P] & keyof AllDbs[G]>>;
// This is the source of the criteria to filter the `dataBaseName` db with.
source: G;
}>
: never;
}
: never;
type Db = DbExpander<keyof AllDbs, keyof AllDbs>;
export type RollupDescription = Readonly<Db[]>;
interface IPFSObject {
Hash: string;
Name?: string;
Size: number;
}
export const databasesToSync: RollupDescription = [
{ databaseName: 'CompleteSetsPurchased' },
{ databaseName: 'CompleteSetsSold' },
{ databaseName: 'DisputeCrowdsourcerContribution' },
{ databaseName: 'DisputeCrowdsourcerCompleted' },
{ databaseName: 'DisputeCrowdsourcerCreated' },
{ databaseName: 'DisputeCrowdsourcerRedeemed' },
{ databaseName: 'DisputeWindowCreated' },
{ databaseName: 'InitialReporterRedeemed' },
{ databaseName: 'InitialReportSubmitted' },
{ databaseName: 'InitialReporterTransferred' },
{ databaseName: 'MarketCreated' },
{ databaseName: 'MarketFinalized' },
{ databaseName: 'MarketMigrated' },
{ databaseName: 'MarketParticipantsDisavowed' },
{ databaseName: 'MarketTransferred' },
{ databaseName: 'MarketVolumeChanged' },
{ databaseName: 'MarketOIChanged' },
{ databaseName: 'OrderEvent' },
{ databaseName: 'ParticipationTokensRedeemed' },
{ databaseName: 'ProfitLossChanged' },
{ databaseName: 'ReportingParticipantDisavowed' },
{ databaseName: 'TimestampSet' },
{ databaseName: 'TokenBalanceChanged' },
{ databaseName: 'TokensMinted' },
{ databaseName: 'TokensTransferred' },
{ databaseName: 'TradingProceedsClaimed' },
{ databaseName: 'UniverseCreated' },
{ databaseName: 'UniverseForked' },
{ databaseName: 'TransferSingle' },
{ databaseName: 'TransferBatch' },
{ databaseName: 'ShareTokenBalanceChanged' },
];
export interface CheckpointInterface {
startBlockNumber: number;
endBlockNumber: number;
logs: SerializedLog[];
}
export class WarpController {
private static DEFAULT_NODE_TYPE = { format: 'dag-pb', hashAlg: 'sha2-256' };
checkpoints: Checkpoints;
ipfs: Promise<IPFS>;
constructor(
private db: DB,
private augur: Augur<Provider>,
private provider: Provider,
private uploadBlockNumber: number,
private ipfsEndpointInfo:IPFSEndpointInfo,
ipfs?: Promise<IPFS>,
) {
this.checkpoints = new Checkpoints(provider);
if (ipfs) {
this.ipfs = ipfs;
} else {
this.ipfs = IPFS.create({
repo: './data',
});
}
}
async getIpfs(): Promise<IPFS> {
return this.ipfs;
}
onNewBlock = async (newBlock: Block): Promise<string | void> => {
await this.createInitialCheckpoint();
/*
0. Base case: need to have created initial warp checkpoint.
1. Check if we need to create warp sync
1. This will happen if the active market endTime has elapsed
2. Check if we have a market awaiting finalization
1. If so, do we dispute?
3. If market is finalized
1. If no dispute we make note of new market end time
*/
const mostRecentCheckpoint = await this.db.warpCheckpoints.getMostRecentCheckpoint();
// Universe not initialized.
if (!mostRecentCheckpoint) {
return;
}
// Warp sync has been created. Need to report, dispute or create next unfinished checkpoint record.
if (mostRecentCheckpoint.end) {
const [marketRecord] = await Markets.getMarketsInfo(this.augur, this.db, {
marketIds: [mostRecentCheckpoint.market],
});
switch (marketRecord.reportingState) {
case MarketReportingState.OpenReporting:
// Emit event to notify UI to report.
break;
case MarketReportingState.AwaitingFinalization:
// confirm hash matches and emit dispute event if needed.
break;
case MarketReportingState.Finalized:
const endBlock = Object.assign({}, mostRecentCheckpoint.end, {
gasLimit: new BigNumber(mostRecentCheckpoint.end.gasLimit),
gasUsed: new BigNumber(mostRecentCheckpoint.end.gasUsed),
})
const [begin, end] = await this.checkpoints.calculateBoundary(
mostRecentCheckpoint.endTimestamp,
endBlock
);
const newWarpSyncMarket = await this.augur.warpSync.getWarpSyncMarket(
this.augur.contracts.universe.address
);
await this.db.warpCheckpoints.createInitialCheckpoint(
end,
newWarpSyncMarket
);
break;
default:
}
return;
}
// WarpSync Market has ended. Need to create checkpoint.
if (mostRecentCheckpoint.endTimestamp < newBlock.timestamp) {
const [
newEndBlock,
newBeginBlock,
] = await this.checkpoints.calculateBoundary(
mostRecentCheckpoint.endTimestamp,
await this.provider.getBlock(this.uploadBlockNumber),
newBlock
);
// Market has finished and now we need to wait 30 blocks.
if (newBlock.number - newEndBlock.number < 30) return;
await this.db.prune(newEndBlock.timestamp);
// This version of the client will no longer generate a
// warp sync because it does not know about the para deploy logs.
}
// nothing left to do.
};
async createInitialCheckpoint() {
const mostRecentCheckpoint = await this.db.warpCheckpoints.getMostRecentCheckpoint();
if (!mostRecentCheckpoint) {
const market = await this.augur.warpSync.getWarpSyncMarket(
this.augur.contracts.universe.address
);
if (market.address === NULL_ADDRESS) {
console.log(
`Warp sync market not initialized for current universe ${this.augur.contracts.universe.address}.`
);
return;
}
await this.db.warpCheckpoints.createInitialCheckpoint(
await this.provider.getBlock(this.uploadBlockNumber),
market
);
}
}
async | () {
await this.db.delete();
await this.db.initializeDB();
}
async createCheckpoint(endBlock: Block): Promise<IpfsInfo> {
const logs = [];
for (const { databaseName } of databasesToSync) {
// Awaiting here to reduce load on db.
logs.push(
await this.db[databaseName]
.where('blockNumber')
.between(this.uploadBlockNumber, endBlock.number, true, true)
.toArray()
);
}
const sortedLogs = _.orderBy(
_.flatten(logs),
['blockNumber', 'logIndex'],
['asc', 'asc']
);
const body = JSON.stringify({
startBlockNumber: this.uploadBlockNumber,
endBlockNumber: endBlock.number,
logs: sortedLogs,
} as CheckpointInterface);
const content = LZString.compressToUint8Array(body);
const [result] = await (await this.ipfs).add({
content,
});
const topLevelDirectory = new DAGNode(
Unixfs.default('directory').marshal()
);
const versionFile = await (await this.ipfs).add({
content: Buffer.from(WARPSYNC_VERSION),
});
topLevelDirectory.addLink({
Name: 'VERSION',
Hash: versionFile[0].hash,
Size: 1,
});
topLevelDirectory.addLink({
Name: 'index',
Hash: result.hash,
Size: 0,
});
const hash = (await (await this.ipfs).dag.put(
topLevelDirectory,
WarpController.DEFAULT_NODE_TYPE
)).toString();
await this.db.warpCheckpoints.createCheckpoint(endBlock, hash);
return hash | destroyAndRecreateDB | identifier_name |
worker.go | if it is not, it is not clear
// why, because the name is delegated to this server according to the parent zone, so we assume that this server
// is broken, but there might be other reasons for this that I can't think off from the top of my head.
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got non-authoritative data from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
}
// If the answer is truncated, we might want to retry over TCP... except of course if the truncated answer is
// already provided over TCP (see Spotify blog post about when it happened to them :))
if ans.Truncated {
if proto == "tcp" {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a truncated answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
}
return w.resolveFromWith(ip, "tcp")
}
for _, grr := range ans.Answer {
// We only consider records from the answer section that have a owner name equal to the qname.
if dns.CompareDomainName(grr.Header().Name, w.req.Name()) == dns.CountLabel(w.req.Name()) && dns.CountLabel(grr.Header().Name) == dns.CountLabel(w.req.Name()){
// We may receive either A or CNAME records with matching owner name. We dismiss all other cases
// (which are probably constituted of NSEC and DNAME and similar stuff. NSEC is of no value here, and DNAME
// are not supported by this tool.
switch rr := grr.(type) {
case *dns.A:
// We stack IPv4 addresses because the RRSet might be composed of multiple A records
ipList = append(ipList, rr.A)
case *dns.CNAME:
// A CNAME is supposed to be the only record at a given domain name. Thus, we return this alias marker
// and forget about all other records that might resides here.
return nameresolver.NewAliasEntry(w.req.Name(), rr.Target), nil
}
}
}
// We now query for the AAAA records to also get the IPv6 addresses
clnt = new(dns.Client)
clnt.Net = proto
maaaa := new(dns.Msg)
maaaa.SetEdns0(4096, false)
maaaa.SetQuestion(w.req.Name(), dns.TypeAAAA)
maaaa.RecursionDesired = false
ans, _, err = clnt.Exchange(maaaa, net.JoinHostPort(ip.String(), "53"))
if err != nil {
errStack := errors.NewErrorStack(err)
errStack.Push(fmt.Errorf("resolveFromWith: error while exchanging with %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
return nil, errStack
}
if ans == nil {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got empty answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if ans.Rcode != dns.RcodeSuccess {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got DNS error %s from %s over %s for %s %s?", dns.RcodeToString[ans.Rcode], ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if !ans.Authoritative {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got non-authoritative data from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if ans.Truncated {
if proto == "tcp" {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a truncated answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
return w.resolveFromWith(ip, "tcp")
}
for _, grr := range ans.Answer {
if dns.CompareDomainName(grr.Header().Name, w.req.Name()) == dns.CountLabel(w.req.Name()) && dns.CountLabel(grr.Header().Name) == dns.CountLabel(w.req.Name()){
switch rr := grr.(type) {
case *dns.AAAA:
ipList = append(ipList, rr.AAAA)
case *dns.CNAME:
// We should have a CNAME here because the CNAME was not returned when asked for A records, and if we
// had received a CNAME, we would already have returned.
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a CNAME that was not provided for the A query from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
}
}
return nameresolver.NewIPEntry(w.req.Name(), ipList), nil
}
// resolveFrom resolves the request associated to this worker. It returns the entry generated from a successful
// resolution or the error that occurred.
func (w *worker) resolveFrom(ip net.IP) (*nameresolver.Entry, *errors.ErrorStack) {
// (proto == "" means UDP)
return w.resolveFromWith(ip, "")
}
// resolveFromGlues tries to resolve the request associated to this worker using the list of servers provided as
// parameters, assuming their are all delegation with glues (i.e. IP addresses of nameservers are already known).
func (w *worker) resolveFromGlues(nameSrvs []*zonecut.NameSrvInfo) (*nameresolver.Entry, *errors.ErrorStack) {
var errList []string
for _, ns := range nameSrvs {
for _, ip := range ns.Addrs() {
// Tries every IP address of every name server. If an error occurs, the next IP, then server is tried.
entry, err := w.resolveFrom(ip)
if err == nil {
return entry, nil
}
errList = append(errList, fmt.Sprintf("resolveFromGlues: error from %s(%s): %s", ns.Name(), ip.String(), err.Error()))
}
}
// No IP address of any server returned a positive result.
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromGlues: no valid glued delegation for %s: [%s]", w.req.Name(), strings.Join(errList, ", ")))
}
// resolveFromGluelessNameSrvs resolves the request associated to this worker using name servers whose IP address is not
// known thanks to glues and in-bailiwick address records. It returns the answer to that request or an error no server
// returned an acceptable response.
func (w *worker) resolveFromGluelessNameSrvs(nameSrvs []*zonecut.NameSrvInfo) (*nameresolver.Entry, *errors.ErrorStack) {
var errList []string
Outerloop:
for _, ns := range nameSrvs {
var addrs []net.IP
// requestedName is the nameserver name, by default. It may evolve, as aliases/CNAME are met along the resolution
requestedName := ns.Name()
// We limit to MAX_CNAME_CHAIN the number of CNAME that we are willing to follow
Innerloop:
for i := 0; i < MAX_CNAME_CHAIN && len(addrs) == 0; i++ {
// Start up the resolution of the name of the nameserver into IP addresses so that we can query these IP
// addresses for the request topic of this worker.
req := nameresolver.NewRequestWithContext(requestedName, w.req.Exceptions(), w.req)
w.nrHandler(req)
ne, err := req.Result()
if err != nil || ne == nil {
// if an error occurred, we just try with the next nameserver until we get an answer or all servers have
// been tried.
continue Outerloop
}
if ne.CNAMETarget() == "" {
// We got some IP addresses ; we store them away and go to the next step
addrs = ne.Addrs()
break Innerloop
}
// If the answer is an alias, we retry with the new target name
requestedName = ne.CNAMETarget()
}
if len(addrs) == 0 {
// We hit a very long CNAME Chain or the name cannot be resolved for some reason
continue
}
// Try to query every IP that we found, until we get a valid answer
for _, addr := range addrs {
entry, err := w.resolveFrom(addr)
if err == nil {
return entry, nil | random_line_split | ||
worker.go | about all other records that might resides here.
return nameresolver.NewAliasEntry(w.req.Name(), rr.Target), nil
}
}
}
// We now query for the AAAA records to also get the IPv6 addresses
clnt = new(dns.Client)
clnt.Net = proto
maaaa := new(dns.Msg)
maaaa.SetEdns0(4096, false)
maaaa.SetQuestion(w.req.Name(), dns.TypeAAAA)
maaaa.RecursionDesired = false
ans, _, err = clnt.Exchange(maaaa, net.JoinHostPort(ip.String(), "53"))
if err != nil {
errStack := errors.NewErrorStack(err)
errStack.Push(fmt.Errorf("resolveFromWith: error while exchanging with %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
return nil, errStack
}
if ans == nil {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got empty answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if ans.Rcode != dns.RcodeSuccess {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got DNS error %s from %s over %s for %s %s?", dns.RcodeToString[ans.Rcode], ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if !ans.Authoritative {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got non-authoritative data from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if ans.Truncated {
if proto == "tcp" {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a truncated answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
return w.resolveFromWith(ip, "tcp")
}
for _, grr := range ans.Answer {
if dns.CompareDomainName(grr.Header().Name, w.req.Name()) == dns.CountLabel(w.req.Name()) && dns.CountLabel(grr.Header().Name) == dns.CountLabel(w.req.Name()){
switch rr := grr.(type) {
case *dns.AAAA:
ipList = append(ipList, rr.AAAA)
case *dns.CNAME:
// We should have a CNAME here because the CNAME was not returned when asked for A records, and if we
// had received a CNAME, we would already have returned.
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a CNAME that was not provided for the A query from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
}
}
return nameresolver.NewIPEntry(w.req.Name(), ipList), nil
}
// resolveFrom resolves the request associated to this worker. It returns the entry generated from a successful
// resolution or the error that occurred.
func (w *worker) resolveFrom(ip net.IP) (*nameresolver.Entry, *errors.ErrorStack) {
// (proto == "" means UDP)
return w.resolveFromWith(ip, "")
}
// resolveFromGlues tries to resolve the request associated to this worker using the list of servers provided as
// parameters, assuming their are all delegation with glues (i.e. IP addresses of nameservers are already known).
func (w *worker) resolveFromGlues(nameSrvs []*zonecut.NameSrvInfo) (*nameresolver.Entry, *errors.ErrorStack) {
var errList []string
for _, ns := range nameSrvs {
for _, ip := range ns.Addrs() {
// Tries every IP address of every name server. If an error occurs, the next IP, then server is tried.
entry, err := w.resolveFrom(ip)
if err == nil {
return entry, nil
}
errList = append(errList, fmt.Sprintf("resolveFromGlues: error from %s(%s): %s", ns.Name(), ip.String(), err.Error()))
}
}
// No IP address of any server returned a positive result.
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromGlues: no valid glued delegation for %s: [%s]", w.req.Name(), strings.Join(errList, ", ")))
}
// resolveFromGluelessNameSrvs resolves the request associated to this worker using name servers whose IP address is not
// known thanks to glues and in-bailiwick address records. It returns the answer to that request or an error no server
// returned an acceptable response.
func (w *worker) resolveFromGluelessNameSrvs(nameSrvs []*zonecut.NameSrvInfo) (*nameresolver.Entry, *errors.ErrorStack) {
var errList []string
Outerloop:
for _, ns := range nameSrvs {
var addrs []net.IP
// requestedName is the nameserver name, by default. It may evolve, as aliases/CNAME are met along the resolution
requestedName := ns.Name()
// We limit to MAX_CNAME_CHAIN the number of CNAME that we are willing to follow
Innerloop:
for i := 0; i < MAX_CNAME_CHAIN && len(addrs) == 0; i++ {
// Start up the resolution of the name of the nameserver into IP addresses so that we can query these IP
// addresses for the request topic of this worker.
req := nameresolver.NewRequestWithContext(requestedName, w.req.Exceptions(), w.req)
w.nrHandler(req)
ne, err := req.Result()
if err != nil || ne == nil {
// if an error occurred, we just try with the next nameserver until we get an answer or all servers have
// been tried.
continue Outerloop
}
if ne.CNAMETarget() == "" {
// We got some IP addresses ; we store them away and go to the next step
addrs = ne.Addrs()
break Innerloop
}
// If the answer is an alias, we retry with the new target name
requestedName = ne.CNAMETarget()
}
if len(addrs) == 0 {
// We hit a very long CNAME Chain or the name cannot be resolved for some reason
continue
}
// Try to query every IP that we found, until we get a valid answer
for _, addr := range addrs {
entry, err := w.resolveFrom(addr)
if err == nil {
return entry, nil
}
errList = append(errList, fmt.Sprintf("resolveFromGluelessNameSrvs: error from %s(%s): %s", ns.Name(), addr.String(), err.Error()))
}
}
// We tried every IP address of every name server to no avail. Return an error
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromGluelessNameSrvs: no valid glueless delegation for %s: [%s]", w.req.Name(), strings.Join(errList, ", ")))
}
// resolve is in charge of orchestrating the resolution of the request that is associated with this worker
func (w *worker) resolve() (*nameresolver.Entry, *errors.ErrorStack) {
// First, we search the list of name servers to which the requested domain name is delegated. This is obtained by
// submitting delegation info request, removing a label each time, until a non-null response is provided (meaning we
// reached the apex of the zone containing the requested name).
var entry *zonecut.Entry
reqName := w.req.Name()
for entry == nil {
var err *errors.ErrorStack
// Get the servers for this zonecut
req := zonecut.NewRequest(reqName, w.req.Exceptions())
w.zcHandler(req)
entry, err = req.Result()
if err != nil {
var returnErr bool
switch typedErr := err.OriginalError().(type) {
case *errors.TimeoutError:
returnErr = true
case *errors.NXDomainError:
returnErr = w.req.Exceptions().RFC8020
case *errors.ServfailError:
returnErr = !w.req.Exceptions().AcceptServFailAsNoData
case *errors.NoNameServerError:
returnErr = false
default:
_ = typedErr
returnErr = true
}
// If we receive an error while searching for the delegation info, we will not be able to perform the
// subsequent queries, so we bail out on this request.
if returnErr | {
err.Push(fmt.Errorf("resolve: error while getting zone cut info of %s for %s", reqName, w.req.Name()))
return nil, err
} | conditional_block | |
worker.go |
// newWorker builds a new worker instance and returns it.
// The worker is started and will resolve the request from a cache file.
func newWorkerWithCachedResult(req *nameresolver.Request, nrHandler func(*nameresolver.Request) *errors.ErrorStack, zcHandler func(*zonecut.Request) *errors.ErrorStack, cf *nameresolver.CacheFile, conf *tools.TransdepConfig) *worker {
w := initNewWorker(req, nrHandler, zcHandler, conf)
w.startWithCachedResult(cf)
return w
}
// handle allows the submission of new requests to this worker.
// This method returns an error if the worker is stopped or if the submitted request does not match the request usually
// handled by this worker.
func (w *worker) handle(req *nameresolver.Request) *errors.ErrorStack {
if w.closedReqChan {
return errors.NewErrorStack(fmt.Errorf("handle: worker channel for name resolution of %s is already closed", w.req.Name()))
} else if !w.req.Equal(req) {
return errors.NewErrorStack(fmt.Errorf("handle: invalid request; the submitted request (%s) does not match the requests handled by this worker (%s)", req.Name(), w.req.Name()))
}
w.reqs <- req
return nil
}
// resolveFromWith resolves the topic of the requests associated with this worker by querying the "ip" IP address and
// using the "proto" protocol (either "" for UDP or "tcp"). It returns an entry corresponding to the requested topic, or an
// definitive error that happened during the resolution.
func (w *worker) resolveFromWith(ip net.IP, proto string) (*nameresolver.Entry, *errors.ErrorStack) {
var ipList []net.IP
// We first query about the IPv4 addresses associated to the request topic.
clnt := new(dns.Client)
clnt.Net = proto
ma := new(dns.Msg)
ma.SetEdns0(4096, false)
ma.SetQuestion(w.req.Name(), dns.TypeA)
ma.RecursionDesired = false
ans, _, err := clnt.Exchange(ma, net.JoinHostPort(ip.String(), "53"))
if err != nil {
errStack := errors.NewErrorStack(err)
errStack.Push(fmt.Errorf("resolveFromWith: error while exchanging with %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
return nil, errStack
}
if ans == nil {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got empty answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
}
if ans.Rcode != dns.RcodeSuccess {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got DNS error %s from %s over %s for %s %s?", dns.RcodeToString[ans.Rcode], ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
}
if !ans.Authoritative {
// We expect an non-empty answer from the server, with a positive answer (no NXDOMAIN (lame delegation),
// no SERVFAIL (broken server)). We also expect the server to be authoritative; if it is not, it is not clear
// why, because the name is delegated to this server according to the parent zone, so we assume that this server
// is broken, but there might be other reasons for this that I can't think off from the top of my head.
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got non-authoritative data from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
}
// If the answer is truncated, we might want to retry over TCP... except of course if the truncated answer is
// already provided over TCP (see Spotify blog post about when it happened to them :))
if ans.Truncated {
if proto == "tcp" {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a truncated answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
}
return w.resolveFromWith(ip, "tcp")
}
for _, grr := range ans.Answer {
// We only consider records from the answer section that have a owner name equal to the qname.
if dns.CompareDomainName(grr.Header().Name, w.req.Name()) == dns.CountLabel(w.req.Name()) && dns.CountLabel(grr.Header().Name) == dns.CountLabel(w.req.Name()){
// We may receive either A or CNAME records with matching owner name. We dismiss all other cases
// (which are probably constituted of NSEC and DNAME and similar stuff. NSEC is of no value here, and DNAME
// are not supported by this tool.
switch rr := grr.(type) {
case *dns.A:
// We stack IPv4 addresses because the RRSet might be composed of multiple A records
ipList = append(ipList, rr.A)
case *dns.CNAME:
// A CNAME is supposed to be the only record at a given domain name. Thus, we return this alias marker
// and forget about all other records that might resides here.
return nameresolver.NewAliasEntry(w.req.Name(), rr.Target), nil
}
}
}
// We now query for the AAAA records to also get the IPv6 addresses
clnt = new(dns.Client)
clnt.Net = proto
maaaa := new(dns.Msg)
maaaa.SetEdns0(4096, false)
maaaa.SetQuestion(w.req.Name(), dns.TypeAAAA)
maaaa.RecursionDesired = false
ans, _, err = clnt.Exchange(maaaa, net.JoinHostPort(ip.String(), "53"))
if err != nil {
errStack := errors.NewErrorStack(err)
errStack.Push(fmt.Errorf("resolveFromWith: error while exchanging with %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
return nil, errStack
}
if ans == nil {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got empty answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if ans.Rcode != dns.RcodeSuccess {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got DNS error %s from %s over %s for %s %s?", dns.RcodeToString[ans.Rcode], ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if !ans.Authoritative {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got non-authoritative data from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if ans.Truncated {
if proto == "tcp" {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a truncated answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
return w.resolveFromWith(ip, "tcp")
}
for _, grr := range ans.Answer {
if dns.CompareDomainName(grr.Header().Name, w.req.Name()) == dns.CountLabel(w.req.Name()) && dns.CountLabel(grr.Header().Name) == dns.CountLabel(w.req.Name()){
switch rr := grr.(type) {
case *dns.AAAA:
ipList = append(ipList, rr.AAAA)
case *dns.CNAME:
// We should have a CNAME here because the CNAME was not returned when asked for A records, and if we
// had received a CNAME, we would already have returned.
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a CNAME that was not provided for the A query from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
}
}
return nameresolver.NewIPEntry(w.req.Name(), ipList), nil
}
// resolveFrom resolves the request associated to this worker. It returns the entry generated from a successful
// resolution or the error that occurred.
func (w *worker) resolveFrom(ip net.IP) (*nameresolver.Entry, *errors.ErrorStack) {
// (proto == "" means | {
w := initNewWorker(req, nrHandler, zcHandler, conf)
w.start()
return w
} | identifier_body | |
worker.go | to the requested topic, or an
// definitive error that happened during the resolution.
func (w *worker) resolveFromWith(ip net.IP, proto string) (*nameresolver.Entry, *errors.ErrorStack) {
var ipList []net.IP
// We first query about the IPv4 addresses associated to the request topic.
clnt := new(dns.Client)
clnt.Net = proto
ma := new(dns.Msg)
ma.SetEdns0(4096, false)
ma.SetQuestion(w.req.Name(), dns.TypeA)
ma.RecursionDesired = false
ans, _, err := clnt.Exchange(ma, net.JoinHostPort(ip.String(), "53"))
if err != nil {
errStack := errors.NewErrorStack(err)
errStack.Push(fmt.Errorf("resolveFromWith: error while exchanging with %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
return nil, errStack
}
if ans == nil {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got empty answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
}
if ans.Rcode != dns.RcodeSuccess {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got DNS error %s from %s over %s for %s %s?", dns.RcodeToString[ans.Rcode], ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
}
if !ans.Authoritative {
// We expect an non-empty answer from the server, with a positive answer (no NXDOMAIN (lame delegation),
// no SERVFAIL (broken server)). We also expect the server to be authoritative; if it is not, it is not clear
// why, because the name is delegated to this server according to the parent zone, so we assume that this server
// is broken, but there might be other reasons for this that I can't think off from the top of my head.
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got non-authoritative data from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
}
// If the answer is truncated, we might want to retry over TCP... except of course if the truncated answer is
// already provided over TCP (see Spotify blog post about when it happened to them :))
if ans.Truncated {
if proto == "tcp" {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a truncated answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeA]))
}
return w.resolveFromWith(ip, "tcp")
}
for _, grr := range ans.Answer {
// We only consider records from the answer section that have a owner name equal to the qname.
if dns.CompareDomainName(grr.Header().Name, w.req.Name()) == dns.CountLabel(w.req.Name()) && dns.CountLabel(grr.Header().Name) == dns.CountLabel(w.req.Name()){
// We may receive either A or CNAME records with matching owner name. We dismiss all other cases
// (which are probably constituted of NSEC and DNAME and similar stuff. NSEC is of no value here, and DNAME
// are not supported by this tool.
switch rr := grr.(type) {
case *dns.A:
// We stack IPv4 addresses because the RRSet might be composed of multiple A records
ipList = append(ipList, rr.A)
case *dns.CNAME:
// A CNAME is supposed to be the only record at a given domain name. Thus, we return this alias marker
// and forget about all other records that might resides here.
return nameresolver.NewAliasEntry(w.req.Name(), rr.Target), nil
}
}
}
// We now query for the AAAA records to also get the IPv6 addresses
clnt = new(dns.Client)
clnt.Net = proto
maaaa := new(dns.Msg)
maaaa.SetEdns0(4096, false)
maaaa.SetQuestion(w.req.Name(), dns.TypeAAAA)
maaaa.RecursionDesired = false
ans, _, err = clnt.Exchange(maaaa, net.JoinHostPort(ip.String(), "53"))
if err != nil {
errStack := errors.NewErrorStack(err)
errStack.Push(fmt.Errorf("resolveFromWith: error while exchanging with %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
return nil, errStack
}
if ans == nil {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got empty answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if ans.Rcode != dns.RcodeSuccess {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got DNS error %s from %s over %s for %s %s?", dns.RcodeToString[ans.Rcode], ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if !ans.Authoritative {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got non-authoritative data from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
if ans.Truncated {
if proto == "tcp" {
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a truncated answer from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
return w.resolveFromWith(ip, "tcp")
}
for _, grr := range ans.Answer {
if dns.CompareDomainName(grr.Header().Name, w.req.Name()) == dns.CountLabel(w.req.Name()) && dns.CountLabel(grr.Header().Name) == dns.CountLabel(w.req.Name()){
switch rr := grr.(type) {
case *dns.AAAA:
ipList = append(ipList, rr.AAAA)
case *dns.CNAME:
// We should have a CNAME here because the CNAME was not returned when asked for A records, and if we
// had received a CNAME, we would already have returned.
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromWith: got a CNAME that was not provided for the A query from %s over %s for %s %s?", ip.String(), errors.PROTO_TO_STR[errors.STR_TO_PROTO[proto]], w.req.Name(), dns.TypeToString[dns.TypeAAAA]))
}
}
}
return nameresolver.NewIPEntry(w.req.Name(), ipList), nil
}
// resolveFrom resolves the request associated to this worker. It returns the entry generated from a successful
// resolution or the error that occurred.
func (w *worker) resolveFrom(ip net.IP) (*nameresolver.Entry, *errors.ErrorStack) {
// (proto == "" means UDP)
return w.resolveFromWith(ip, "")
}
// resolveFromGlues tries to resolve the request associated to this worker using the list of servers provided as
// parameters, assuming their are all delegation with glues (i.e. IP addresses of nameservers are already known).
func (w *worker) resolveFromGlues(nameSrvs []*zonecut.NameSrvInfo) (*nameresolver.Entry, *errors.ErrorStack) {
var errList []string
for _, ns := range nameSrvs {
for _, ip := range ns.Addrs() {
// Tries every IP address of every name server. If an error occurs, the next IP, then server is tried.
entry, err := w.resolveFrom(ip)
if err == nil {
return entry, nil
}
errList = append(errList, fmt.Sprintf("resolveFromGlues: error from %s(%s): %s", ns.Name(), ip.String(), err.Error()))
}
}
// No IP address of any server returned a positive result.
return nil, errors.NewErrorStack(fmt.Errorf("resolveFromGlues: no valid glued delegation for %s: [%s]", w.req.Name(), strings.Join(errList, ", ")))
}
// resolveFromGluelessNameSrvs resolves the request associated to this worker using name servers whose IP address is not
// known thanks to glues and in-bailiwick address records. It returns the answer to that request or an error no server
// returned an acceptable response.
func (w *worker) | resolveFromGluelessNameSrvs | identifier_name | |
project_tasks.py | from ConfigParser import ConfigParser, NoSectionError
# noinspection PyUnresolvedReferences
from herring.herring_app import task, HerringFile
# noinspection PyUnresolvedReferences
from herringlib.simple_logger import info, debug
# noinspection PyUnresolvedReferences
from herringlib.local_shell import LocalShell
# noinspection PyUnresolvedReferences
from herringlib.requirements import Requirements, Requirement
# noinspection PyUnresolvedReferences
from herringlib.project_settings import Project, ATTRIBUTES
missing_modules = []
def value_from_setup_py(arg_name):
"""
Use AST to find the name value in the setup() call in setup.py.
Only works for key=string arguments to setup().
:param arg_name: the keyword argument name passed to the setup() call in setup.py.
:type arg_name: str
:returns: the name value or None
:rtype: str|None
"""
setup_py = 'setup.py'
if os.path.isfile(setup_py):
# scan setup.py for a call to 'setup'.
tree = ast.parse(''.join(open(setup_py)))
call_nodes = [node.value for node in tree.body if type(node) == ast.Expr and type(node.value) == ast.Call]
# noinspection PyShadowingNames
def is_setup(call_node):
try:
return call_node.func.id == 'setup'
except AttributeError as ex:
try:
return call_node.func.value.id == 'setup'
except AttributeError as ex:
print(str(ex))
print(ast.dump(call_node.func))
print(ast.dump(call_node))
keywords = [call_node.keywords for call_node in call_nodes if is_setup(call_node)]
# now setup() takes keyword arguments so scan them looking for key that matches the given arg_name,
# then return the keyword's value
for keyword in keywords:
for keyword_arg in keyword:
if keyword_arg.arg == arg_name:
if hasattr(keyword_arg.value, 's'):
return keyword_arg.value.s
# didn't find it
return None
def _project_defaults():
"""
Get the project defaults from (in order of preference):
* setup.py,
* kwargs,
* herring config file,
* environment variables,
* default values.
:return: dictionary of defaults
:rtype: dict[str,str]
"""
defaults = {
'package': os.path.basename(os.path.abspath(os.curdir)),
'name': os.path.basename(os.path.abspath(os.curdir)).capitalize(),
'description': 'The greatest project there ever was or will be!',
'author': 'author',
'title': os.path.basename(os.path.abspath(os.curdir)).capitalize(),
}
if 'USER' in os.environ:
defaults['author'] = os.environ['USER']
defaults['author_email'] = '{author}@example.com'.format(author=defaults['author'])
# override defaults from herringfile
# for key in ['name', 'author', 'author_email', 'description']:
# attributes = Project.attributes()
# for key in [key for key in attributes.keys() if attributes[key] is not None]:
# # noinspection PyBroadException
# try:
# value = getattr(Project, key, None)
# if value is not None:
# defaults[key] = value
# except:
# pass
# override defaults from any config files
settings = HerringFile.settings
if settings is not None:
config = ConfigParser()
config.read(settings.config_files)
for section in ['project']:
try:
defaults.update(dict(config.items(section)))
except NoSectionError:
pass
# override defaults from kwargs
for key in task.kwargs:
defaults[key] = task.kwargs[key]
# override defaults from setup.py
for key in ['name', 'author', 'author_email', 'description']:
value = value_from_setup_py(key)
if value is not None:
defaults[key] = value
# now add any attributes that are not already in defaults
for key in ATTRIBUTES:
if key not in defaults:
value = getattr(Project, key, None)
if value is not None:
defaults[key] = value
else:
print("{key}:None".format(key=key))
return defaults
@task(namespace='project', help='Available options: --name, --package, --author, --author_email, --description',
kwargs=['name', 'package', 'author', 'author_email', 'description'], configured='no')
def init():
"""
Initialize a new python project with default files. Default values from herring.conf and directory name.
"""
defaults = _project_defaults()
if Project.prompt:
defaults['name'] = prompt("Enter the project's name:", defaults['name'])
defaults['package'] = prompt("Enter the project's package:", defaults['package'])
defaults['author'] = prompt("Enter the project's author:", defaults['author'])
defaults['author_email'] = prompt("Enter the project's author's email:", defaults['author_email'])
defaults['description'] = prompt("Enter the project's description:", defaults['description'])
# print("defaults:\n{defaults}".format(defaults=pformat(defaults)))
if Project.use_templates:
template = Template()
for template_dir in [os.path.abspath(os.path.join(herringlib, 'herringlib', 'templates'))
for herringlib in HerringFile.herringlib_paths]:
info("template directory: %s" % template_dir)
# noinspection PyArgumentEqualDefault
template.generate(template_dir, defaults, overwrite=False)
@task(namespace='project')
def update():
"""
Regenerate files (except herringfile) from current templates.
Delete the file(s) you want to update, then run this task.
"""
if Project.use_templates:
defaults = _project_defaults()
template = Template()
for template_dir in [os.path.abspath(os.path.join(herringlib, 'herringlib', 'templates'))
for herringlib in HerringFile.herringlib_paths]:
info("template directory: %s" % template_dir)
# noinspection PyArgumentEqualDefault
template.generate(template_dir, defaults, overwrite=False)
@task(namespace='project', configured='optional')
def show():
"""Show all project settings"""
info(str(Project))
@task(namespace='project', configured='optional')
def | ():
"""Show all project settings with descriptions"""
keys = Project.__dict__.keys()
for key in sorted(keys):
value = Project.__dict__[key]
if key in ATTRIBUTES:
attrs = ATTRIBUTES[key]
required = False
if 'required' in attrs:
if attrs['required']:
required = True
if 'help' in attrs:
info("# {key}".format(key=key))
if required:
info("# REQUIRED")
for line in textwrap.wrap(attrs['help'], width=100):
info("# {line}".format(line=line))
info("# '{key}': '{value}'".format(key=key, value=value))
info('')
else:
info("'{key}': '{value}'".format(key=key, value=value))
def _pip_list():
names = []
# noinspection PyBroadException
try:
# idiotic python setup tools creates empty egg directory in project that then causes pip to blow up.
# Wonderful python tools in action!
# so lets remove the stupid egg directory so we can use pip to get a listing of installed packages.
egg_info_dir = "{name}.egg-info".format(name=Project.name)
if os.path.exists(egg_info_dir):
shutil.rmtree(egg_info_dir)
with LocalShell() as local:
# if 'VIRTUAL_ENV' in os.environ:
# pip = os.path.join(os.environ['VIRTUAL_ENV'], 'bin', 'pip')
# info("PATH={path}".format(path=os.environ['PATH']))
# info(pip)
pip = local.system('which pip || which pip3', verbose=False).strip()
# info(pip)
# info("pip version: {ver}".format(ver=local.system('{pip} --version'.format(pip=pip))))
pip_list_output = local.run('{pip} list'.format(pip=pip))
# info(pip_list_output)
lines = pip_list_output.split("\n")
names = [line.split(" ")[0].lower().encode('ascii', 'ignore') for line in lines if line.strip()]
except Exception:
pass
return names
# noinspection PyArgumentEqualDefault
__pip_list = [pkg.decode('utf-8') for pkg in _pip_list()]
def packages_required(package_names):
"""
Check that the given packages are installed.
:param package_names: the package names
:type package_names: list
:return: asserted if all the packages are installed
:rtype: bool
"""
# info("packages_required(%s)" % repr(package_names))
# noinspection PyBroadException
try:
result = True
# info(package_names)
# info(__pip_list)
for requirement in [Requirement(name) for name in package_names]:
if requirement.supported_python():
pkg_name = requirement.package
if pkg_name.lower() not in __pip_list:
try:
# info('__import__("{name}")'.format(name=pkg_name))
__import__(pkg_name)
except ImportError:
info(pkg_name + | describe | identifier_name |
project_tasks.py | from ConfigParser import ConfigParser, NoSectionError
# noinspection PyUnresolvedReferences
from herring.herring_app import task, HerringFile
# noinspection PyUnresolvedReferences
from herringlib.simple_logger import info, debug
# noinspection PyUnresolvedReferences
from herringlib.local_shell import LocalShell
# noinspection PyUnresolvedReferences
from herringlib.requirements import Requirements, Requirement
# noinspection PyUnresolvedReferences
from herringlib.project_settings import Project, ATTRIBUTES
missing_modules = []
def value_from_setup_py(arg_name):
"""
Use AST to find the name value in the setup() call in setup.py.
Only works for key=string arguments to setup().
:param arg_name: the keyword argument name passed to the setup() call in setup.py.
:type arg_name: str
:returns: the name value or None
:rtype: str|None
"""
setup_py = 'setup.py'
if os.path.isfile(setup_py):
# scan setup.py for a call to 'setup'.
tree = ast.parse(''.join(open(setup_py)))
call_nodes = [node.value for node in tree.body if type(node) == ast.Expr and type(node.value) == ast.Call]
# noinspection PyShadowingNames
def is_setup(call_node):
try:
return call_node.func.id == 'setup'
except AttributeError as ex:
try:
return call_node.func.value.id == 'setup'
except AttributeError as ex:
print(str(ex))
print(ast.dump(call_node.func))
print(ast.dump(call_node))
keywords = [call_node.keywords for call_node in call_nodes if is_setup(call_node)]
# now setup() takes keyword arguments so scan them looking for key that matches the given arg_name,
# then return the keyword's value
for keyword in keywords:
for keyword_arg in keyword:
if keyword_arg.arg == arg_name:
if hasattr(keyword_arg.value, 's'):
return keyword_arg.value.s
# didn't find it
return None
def _project_defaults():
"""
Get the project defaults from (in order of preference):
* setup.py,
* kwargs,
* herring config file,
* environment variables,
* default values.
:return: dictionary of defaults
:rtype: dict[str,str]
"""
defaults = {
'package': os.path.basename(os.path.abspath(os.curdir)),
'name': os.path.basename(os.path.abspath(os.curdir)).capitalize(),
'description': 'The greatest project there ever was or will be!',
'author': 'author',
'title': os.path.basename(os.path.abspath(os.curdir)).capitalize(),
}
if 'USER' in os.environ:
defaults['author'] = os.environ['USER']
defaults['author_email'] = '{author}@example.com'.format(author=defaults['author'])
# override defaults from herringfile
# for key in ['name', 'author', 'author_email', 'description']:
# attributes = Project.attributes()
# for key in [key for key in attributes.keys() if attributes[key] is not None]:
# # noinspection PyBroadException
# try:
# value = getattr(Project, key, None)
# if value is not None:
# defaults[key] = value
# except:
# pass
# override defaults from any config files
settings = HerringFile.settings
if settings is not None:
config = ConfigParser()
config.read(settings.config_files)
for section in ['project']:
try:
defaults.update(dict(config.items(section)))
except NoSectionError:
pass
# override defaults from kwargs
for key in task.kwargs:
defaults[key] = task.kwargs[key]
# override defaults from setup.py
for key in ['name', 'author', 'author_email', 'description']:
value = value_from_setup_py(key)
if value is not None:
defaults[key] = value
# now add any attributes that are not already in defaults
for key in ATTRIBUTES:
if key not in defaults:
value = getattr(Project, key, None)
if value is not None:
defaults[key] = value
else:
print("{key}:None".format(key=key))
return defaults
@task(namespace='project', help='Available options: --name, --package, --author, --author_email, --description',
kwargs=['name', 'package', 'author', 'author_email', 'description'], configured='no')
def init():
"""
Initialize a new python project with default files. Default values from herring.conf and directory name.
"""
defaults = _project_defaults()
if Project.prompt:
defaults['name'] = prompt("Enter the project's name:", defaults['name'])
defaults['package'] = prompt("Enter the project's package:", defaults['package'])
defaults['author'] = prompt("Enter the project's author:", defaults['author'])
defaults['author_email'] = prompt("Enter the project's author's email:", defaults['author_email'])
defaults['description'] = prompt("Enter the project's description:", defaults['description'])
# print("defaults:\n{defaults}".format(defaults=pformat(defaults)))
if Project.use_templates:
template = Template()
for template_dir in [os.path.abspath(os.path.join(herringlib, 'herringlib', 'templates'))
for herringlib in HerringFile.herringlib_paths]:
info("template directory: %s" % template_dir)
# noinspection PyArgumentEqualDefault
template.generate(template_dir, defaults, overwrite=False)
@task(namespace='project')
def update():
"""
Regenerate files (except herringfile) from current templates.
Delete the file(s) you want to update, then run this task.
"""
if Project.use_templates:
defaults = _project_defaults()
template = Template()
for template_dir in [os.path.abspath(os.path.join(herringlib, 'herringlib', 'templates'))
for herringlib in HerringFile.herringlib_paths]:
info("template directory: %s" % template_dir)
# noinspection PyArgumentEqualDefault
template.generate(template_dir, defaults, overwrite=False)
@task(namespace='project', configured='optional')
def show():
|
@task(namespace='project', configured='optional')
def describe():
"""Show all project settings with descriptions"""
keys = Project.__dict__.keys()
for key in sorted(keys):
value = Project.__dict__[key]
if key in ATTRIBUTES:
attrs = ATTRIBUTES[key]
required = False
if 'required' in attrs:
if attrs['required']:
required = True
if 'help' in attrs:
info("# {key}".format(key=key))
if required:
info("# REQUIRED")
for line in textwrap.wrap(attrs['help'], width=100):
info("# {line}".format(line=line))
info("# '{key}': '{value}'".format(key=key, value=value))
info('')
else:
info("'{key}': '{value}'".format(key=key, value=value))
def _pip_list():
names = []
# noinspection PyBroadException
try:
# idiotic python setup tools creates empty egg directory in project that then causes pip to blow up.
# Wonderful python tools in action!
# so lets remove the stupid egg directory so we can use pip to get a listing of installed packages.
egg_info_dir = "{name}.egg-info".format(name=Project.name)
if os.path.exists(egg_info_dir):
shutil.rmtree(egg_info_dir)
with LocalShell() as local:
# if 'VIRTUAL_ENV' in os.environ:
# pip = os.path.join(os.environ['VIRTUAL_ENV'], 'bin', 'pip')
# info("PATH={path}".format(path=os.environ['PATH']))
# info(pip)
pip = local.system('which pip || which pip3', verbose=False).strip()
# info(pip)
# info("pip version: {ver}".format(ver=local.system('{pip} --version'.format(pip=pip))))
pip_list_output = local.run('{pip} list'.format(pip=pip))
# info(pip_list_output)
lines = pip_list_output.split("\n")
names = [line.split(" ")[0].lower().encode('ascii', 'ignore') for line in lines if line.strip()]
except Exception:
pass
return names
# noinspection PyArgumentEqualDefault
__pip_list = [pkg.decode('utf-8') for pkg in _pip_list()]
def packages_required(package_names):
"""
Check that the given packages are installed.
:param package_names: the package names
:type package_names: list
:return: asserted if all the packages are installed
:rtype: bool
"""
# info("packages_required(%s)" % repr(package_names))
# noinspection PyBroadException
try:
result = True
# info(package_names)
# info(__pip_list)
for requirement in [Requirement(name) for name in package_names]:
if requirement.supported_python():
pkg_name = requirement.package
if pkg_name.lower() not in __pip_list:
try:
# info('__import__("{name}")'.format(name=pkg_name))
__import__(pkg_name)
except ImportError:
info(pkg_name + | """Show all project settings"""
info(str(Project)) | identifier_body |
project_tasks.py | from ConfigParser import ConfigParser, NoSectionError
# noinspection PyUnresolvedReferences
from herring.herring_app import task, HerringFile
# noinspection PyUnresolvedReferences
from herringlib.simple_logger import info, debug
# noinspection PyUnresolvedReferences
from herringlib.local_shell import LocalShell
# noinspection PyUnresolvedReferences
from herringlib.requirements import Requirements, Requirement
# noinspection PyUnresolvedReferences
from herringlib.project_settings import Project, ATTRIBUTES
missing_modules = []
def value_from_setup_py(arg_name):
"""
Use AST to find the name value in the setup() call in setup.py.
Only works for key=string arguments to setup().
:param arg_name: the keyword argument name passed to the setup() call in setup.py.
:type arg_name: str
:returns: the name value or None
:rtype: str|None
"""
setup_py = 'setup.py'
if os.path.isfile(setup_py):
# scan setup.py for a call to 'setup'.
tree = ast.parse(''.join(open(setup_py)))
call_nodes = [node.value for node in tree.body if type(node) == ast.Expr and type(node.value) == ast.Call]
# noinspection PyShadowingNames
def is_setup(call_node):
try:
return call_node.func.id == 'setup'
except AttributeError as ex:
try:
return call_node.func.value.id == 'setup'
except AttributeError as ex:
print(str(ex))
print(ast.dump(call_node.func))
print(ast.dump(call_node))
keywords = [call_node.keywords for call_node in call_nodes if is_setup(call_node)]
# now setup() takes keyword arguments so scan them looking for key that matches the given arg_name,
# then return the keyword's value
for keyword in keywords:
for keyword_arg in keyword:
if keyword_arg.arg == arg_name:
if hasattr(keyword_arg.value, 's'):
return keyword_arg.value.s
# didn't find it
return None
def _project_defaults():
"""
Get the project defaults from (in order of preference):
* setup.py,
* kwargs,
* herring config file,
* environment variables,
* default values.
:return: dictionary of defaults
:rtype: dict[str,str]
"""
defaults = {
'package': os.path.basename(os.path.abspath(os.curdir)),
'name': os.path.basename(os.path.abspath(os.curdir)).capitalize(),
'description': 'The greatest project there ever was or will be!',
'author': 'author',
'title': os.path.basename(os.path.abspath(os.curdir)).capitalize(),
}
if 'USER' in os.environ:
defaults['author'] = os.environ['USER']
defaults['author_email'] = '{author}@example.com'.format(author=defaults['author'])
# override defaults from herringfile
# for key in ['name', 'author', 'author_email', 'description']:
# attributes = Project.attributes()
# for key in [key for key in attributes.keys() if attributes[key] is not None]:
# # noinspection PyBroadException
# try:
# value = getattr(Project, key, None)
# if value is not None:
# defaults[key] = value
# except:
# pass
# override defaults from any config files
settings = HerringFile.settings
if settings is not None:
config = ConfigParser()
config.read(settings.config_files)
for section in ['project']:
try:
defaults.update(dict(config.items(section)))
except NoSectionError:
pass
# override defaults from kwargs
for key in task.kwargs:
defaults[key] = task.kwargs[key]
# override defaults from setup.py
for key in ['name', 'author', 'author_email', 'description']:
value = value_from_setup_py(key)
if value is not None:
defaults[key] = value
# now add any attributes that are not already in defaults
for key in ATTRIBUTES:
if key not in defaults:
value = getattr(Project, key, None)
if value is not None:
defaults[key] = value
else:
print("{key}:None".format(key=key))
return defaults
@task(namespace='project', help='Available options: --name, --package, --author, --author_email, --description',
kwargs=['name', 'package', 'author', 'author_email', 'description'], configured='no')
def init():
"""
Initialize a new python project with default files. Default values from herring.conf and directory name.
"""
defaults = _project_defaults()
if Project.prompt:
defaults['name'] = prompt("Enter the project's name:", defaults['name'])
defaults['package'] = prompt("Enter the project's package:", defaults['package'])
defaults['author'] = prompt("Enter the project's author:", defaults['author'])
defaults['author_email'] = prompt("Enter the project's author's email:", defaults['author_email'])
defaults['description'] = prompt("Enter the project's description:", defaults['description'])
# print("defaults:\n{defaults}".format(defaults=pformat(defaults)))
if Project.use_templates:
template = Template()
for template_dir in [os.path.abspath(os.path.join(herringlib, 'herringlib', 'templates'))
for herringlib in HerringFile.herringlib_paths]:
info("template directory: %s" % template_dir)
# noinspection PyArgumentEqualDefault
template.generate(template_dir, defaults, overwrite=False)
@task(namespace='project')
def update():
"""
Regenerate files (except herringfile) from current templates.
Delete the file(s) you want to update, then run this task.
"""
if Project.use_templates:
|
@task(namespace='project', configured='optional')
def show():
"""Show all project settings"""
info(str(Project))
@task(namespace='project', configured='optional')
def describe():
"""Show all project settings with descriptions"""
keys = Project.__dict__.keys()
for key in sorted(keys):
value = Project.__dict__[key]
if key in ATTRIBUTES:
attrs = ATTRIBUTES[key]
required = False
if 'required' in attrs:
if attrs['required']:
required = True
if 'help' in attrs:
info("# {key}".format(key=key))
if required:
info("# REQUIRED")
for line in textwrap.wrap(attrs['help'], width=100):
info("# {line}".format(line=line))
info("# '{key}': '{value}'".format(key=key, value=value))
info('')
else:
info("'{key}': '{value}'".format(key=key, value=value))
def _pip_list():
names = []
# noinspection PyBroadException
try:
# idiotic python setup tools creates empty egg directory in project that then causes pip to blow up.
# Wonderful python tools in action!
# so lets remove the stupid egg directory so we can use pip to get a listing of installed packages.
egg_info_dir = "{name}.egg-info".format(name=Project.name)
if os.path.exists(egg_info_dir):
shutil.rmtree(egg_info_dir)
with LocalShell() as local:
# if 'VIRTUAL_ENV' in os.environ:
# pip = os.path.join(os.environ['VIRTUAL_ENV'], 'bin', 'pip')
# info("PATH={path}".format(path=os.environ['PATH']))
# info(pip)
pip = local.system('which pip || which pip3', verbose=False).strip()
# info(pip)
# info("pip version: {ver}".format(ver=local.system('{pip} --version'.format(pip=pip))))
pip_list_output = local.run('{pip} list'.format(pip=pip))
# info(pip_list_output)
lines = pip_list_output.split("\n")
names = [line.split(" ")[0].lower().encode('ascii', 'ignore') for line in lines if line.strip()]
except Exception:
pass
return names
# noinspection PyArgumentEqualDefault
__pip_list = [pkg.decode('utf-8') for pkg in _pip_list()]
def packages_required(package_names):
"""
Check that the given packages are installed.
:param package_names: the package names
:type package_names: list
:return: asserted if all the packages are installed
:rtype: bool
"""
# info("packages_required(%s)" % repr(package_names))
# noinspection PyBroadException
try:
result = True
# info(package_names)
# info(__pip_list)
for requirement in [Requirement(name) for name in package_names]:
if requirement.supported_python():
pkg_name = requirement.package
if pkg_name.lower() not in __pip_list:
try:
# info('__import__("{name}")'.format(name=pkg_name))
__import__(pkg_name)
except ImportError:
info(pkg_name + | defaults = _project_defaults()
template = Template()
for template_dir in [os.path.abspath(os.path.join(herringlib, 'herringlib', 'templates'))
for herringlib in HerringFile.herringlib_paths]:
info("template directory: %s" % template_dir)
# noinspection PyArgumentEqualDefault
template.generate(template_dir, defaults, overwrite=False) | conditional_block |
project_tasks.py | except ImportError:
# python2
# noinspection PyUnresolvedReferences,PyCompatibility
from ConfigParser import ConfigParser, NoSectionError
# noinspection PyUnresolvedReferences
from herring.herring_app import task, HerringFile
# noinspection PyUnresolvedReferences
from herringlib.simple_logger import info, debug
# noinspection PyUnresolvedReferences
from herringlib.local_shell import LocalShell
# noinspection PyUnresolvedReferences
from herringlib.requirements import Requirements, Requirement
# noinspection PyUnresolvedReferences
from herringlib.project_settings import Project, ATTRIBUTES
missing_modules = []
def value_from_setup_py(arg_name):
"""
Use AST to find the name value in the setup() call in setup.py.
Only works for key=string arguments to setup().
:param arg_name: the keyword argument name passed to the setup() call in setup.py.
:type arg_name: str
:returns: the name value or None
:rtype: str|None
"""
setup_py = 'setup.py'
if os.path.isfile(setup_py):
# scan setup.py for a call to 'setup'.
tree = ast.parse(''.join(open(setup_py)))
call_nodes = [node.value for node in tree.body if type(node) == ast.Expr and type(node.value) == ast.Call]
# noinspection PyShadowingNames
def is_setup(call_node):
try:
return call_node.func.id == 'setup'
except AttributeError as ex:
try:
return call_node.func.value.id == 'setup'
except AttributeError as ex:
print(str(ex))
print(ast.dump(call_node.func))
print(ast.dump(call_node))
keywords = [call_node.keywords for call_node in call_nodes if is_setup(call_node)]
# now setup() takes keyword arguments so scan them looking for key that matches the given arg_name,
# then return the keyword's value
for keyword in keywords:
for keyword_arg in keyword:
if keyword_arg.arg == arg_name:
if hasattr(keyword_arg.value, 's'):
return keyword_arg.value.s
# didn't find it
return None
def _project_defaults():
"""
Get the project defaults from (in order of preference):
* setup.py,
* kwargs,
* herring config file,
* environment variables,
* default values.
:return: dictionary of defaults
:rtype: dict[str,str]
"""
defaults = {
'package': os.path.basename(os.path.abspath(os.curdir)),
'name': os.path.basename(os.path.abspath(os.curdir)).capitalize(),
'description': 'The greatest project there ever was or will be!',
'author': 'author',
'title': os.path.basename(os.path.abspath(os.curdir)).capitalize(),
}
if 'USER' in os.environ:
defaults['author'] = os.environ['USER']
defaults['author_email'] = '{author}@example.com'.format(author=defaults['author'])
# override defaults from herringfile
# for key in ['name', 'author', 'author_email', 'description']:
# attributes = Project.attributes()
# for key in [key for key in attributes.keys() if attributes[key] is not None]:
# # noinspection PyBroadException
# try:
# value = getattr(Project, key, None)
# if value is not None:
# defaults[key] = value
# except:
# pass
# override defaults from any config files
settings = HerringFile.settings
if settings is not None:
config = ConfigParser()
config.read(settings.config_files)
for section in ['project']:
try:
defaults.update(dict(config.items(section)))
except NoSectionError:
pass
# override defaults from kwargs
for key in task.kwargs:
defaults[key] = task.kwargs[key]
# override defaults from setup.py
for key in ['name', 'author', 'author_email', 'description']:
value = value_from_setup_py(key)
if value is not None:
defaults[key] = value
# now add any attributes that are not already in defaults
for key in ATTRIBUTES:
if key not in defaults:
value = getattr(Project, key, None)
if value is not None:
defaults[key] = value
else:
print("{key}:None".format(key=key))
return defaults
@task(namespace='project', help='Available options: --name, --package, --author, --author_email, --description',
kwargs=['name', 'package', 'author', 'author_email', 'description'], configured='no')
def init():
"""
Initialize a new python project with default files. Default values from herring.conf and directory name.
"""
defaults = _project_defaults()
if Project.prompt:
defaults['name'] = prompt("Enter the project's name:", defaults['name'])
defaults['package'] = prompt("Enter the project's package:", defaults['package'])
defaults['author'] = prompt("Enter the project's author:", defaults['author'])
defaults['author_email'] = prompt("Enter the project's author's email:", defaults['author_email'])
defaults['description'] = prompt("Enter the project's description:", defaults['description'])
# print("defaults:\n{defaults}".format(defaults=pformat(defaults)))
if Project.use_templates:
template = Template()
for template_dir in [os.path.abspath(os.path.join(herringlib, 'herringlib', 'templates'))
for herringlib in HerringFile.herringlib_paths]:
info("template directory: %s" % template_dir)
# noinspection PyArgumentEqualDefault
template.generate(template_dir, defaults, overwrite=False)
@task(namespace='project')
def update():
"""
Regenerate files (except herringfile) from current templates.
Delete the file(s) you want to update, then run this task.
"""
if Project.use_templates:
defaults = _project_defaults()
template = Template()
for template_dir in [os.path.abspath(os.path.join(herringlib, 'herringlib', 'templates'))
for herringlib in HerringFile.herringlib_paths]:
info("template directory: %s" % template_dir)
# noinspection PyArgumentEqualDefault
template.generate(template_dir, defaults, overwrite=False)
@task(namespace='project', configured='optional')
def show():
"""Show all project settings"""
info(str(Project))
@task(namespace='project', configured='optional')
def describe():
"""Show all project settings with descriptions"""
keys = Project.__dict__.keys()
for key in sorted(keys):
value = Project.__dict__[key]
if key in ATTRIBUTES:
attrs = ATTRIBUTES[key]
required = False
if 'required' in attrs:
if attrs['required']:
required = True
if 'help' in attrs:
info("# {key}".format(key=key))
if required:
info("# REQUIRED")
for line in textwrap.wrap(attrs['help'], width=100):
info("# {line}".format(line=line))
info("# '{key}': '{value}'".format(key=key, value=value))
info('')
else:
info("'{key}': '{value}'".format(key=key, value=value))
def _pip_list():
names = []
# noinspection PyBroadException
try:
# idiotic python setup tools creates empty egg directory in project that then causes pip to blow up.
# Wonderful python tools in action!
# so lets remove the stupid egg directory so we can use pip to get a listing of installed packages.
egg_info_dir = "{name}.egg-info".format(name=Project.name)
if os.path.exists(egg_info_dir):
shutil.rmtree(egg_info_dir)
with LocalShell() as local:
# if 'VIRTUAL_ENV' in os.environ:
# pip = os.path.join(os.environ['VIRTUAL_ENV'], 'bin', 'pip')
# info("PATH={path}".format(path=os.environ['PATH']))
# info(pip)
pip = local.system('which pip || which pip3', verbose=False).strip()
# info(pip)
# info("pip version: {ver}".format(ver=local.system('{pip} --version'.format(pip=pip))))
pip_list_output = local.run('{pip} list'.format(pip=pip))
# info(pip_list_output)
lines = pip_list_output.split("\n")
names = [line.split(" ")[0].lower().encode('ascii', 'ignore') for line in lines if line.strip()]
except Exception:
pass
return names
# noinspection PyArgumentEqualDefault
__pip_list = [pkg.decode('utf-8') for pkg in _pip_list()]
def packages_required(package_names):
"""
Check that the given packages are installed.
:param package_names: the package names
:type package_names: list
:return: asserted if all the packages are installed
:rtype: bool
"""
# info("packages_required(%s)" % repr(package_names))
# noinspection PyBroadException
try:
result = True
# info(package_names)
# info(__pip_list)
for requirement in [Requirement(name) for name in package_names]:
if requirement.supported_python():
pkg_name = requirement.package | try:
# python3
# noinspection PyUnresolvedReferences,PyCompatibility
from configparser import ConfigParser, NoSectionError | random_line_split | |
container.go | &Container{
logger: logger,
Name: name,
runtime: runtime,
client: client,
}
}
// MakeContainer constructs a suitable Container object.
//
// The runtime used is determined by the runtime flag.
//
// Containers will check flags for profiling requests.
func MakeContainer(ctx context.Context, logger testutil.Logger) *Container {
return makeContainer(ctx, logger, *runtime)
}
// MakeContainerWithRuntime is like MakeContainer, but allows for a runtime
// to be specified by suffix.
func MakeContainerWithRuntime(ctx context.Context, logger testutil.Logger, suffix string) *Container {
return makeContainer(ctx, logger, *runtime+suffix)
}
// MakeNativeContainer constructs a suitable Container object.
//
// The runtime used will be the system default.
//
// Native containers aren't profiled.
func MakeNativeContainer(ctx context.Context, logger testutil.Logger) *Container {
unsandboxedRuntime := "runc"
if override, found := os.LookupEnv("UNSANDBOXED_RUNTIME"); found {
unsandboxedRuntime = override
}
return makeContainer(ctx, logger, unsandboxedRuntime)
}
// Spawn is analogous to 'docker run -d'.
func (c *Container) Spawn(ctx context.Context, r RunOpts, args ...string) error {
if err := c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil); err != nil {
return err
}
return c.Start(ctx)
}
// SpawnProcess is analogous to 'docker run -it'. It returns a process
// which represents the root process.
func (c *Container) SpawnProcess(ctx context.Context, r RunOpts, args ...string) (Process, error) {
config, hostconf, netconf := c.ConfigsFrom(r, args...)
config.Tty = true
config.OpenStdin = true
if err := c.CreateFrom(ctx, r.Image, config, hostconf, netconf); err != nil {
return Process{}, err
}
// Open a connection to the container for parsing logs and for TTY.
stream, err := c.client.ContainerAttach(ctx, c.id,
types.ContainerAttachOptions{
Stream: true,
Stdin: true,
Stdout: true,
Stderr: true,
})
if err != nil {
return Process{}, fmt.Errorf("connect failed container id %s: %v", c.id, err)
}
c.cleanups = append(c.cleanups, func() { stream.Close() })
if err := c.Start(ctx); err != nil {
return Process{}, err
}
return Process{container: c, conn: stream}, nil
}
// Run is analogous to 'docker run'.
func (c *Container) Run(ctx context.Context, r RunOpts, args ...string) (string, error) {
if err := c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil); err != nil {
return "", err
}
if err := c.Start(ctx); err != nil {
return "", err
}
if err := c.Wait(ctx); err != nil {
return "", err
}
return c.Logs(ctx)
}
// ConfigsFrom returns container configs from RunOpts and args. The caller should call 'CreateFrom'
// and Start.
func (c *Container) ConfigsFrom(r RunOpts, args ...string) (*container.Config, *container.HostConfig, *network.NetworkingConfig) {
return c.config(r, args), c.hostConfig(r), &network.NetworkingConfig{}
}
// MakeLink formats a link to add to a RunOpts.
func (c *Container) MakeLink(target string) string {
return fmt.Sprintf("%s:%s", c.Name, target)
}
// CreateFrom creates a container from the given configs.
func (c *Container) CreateFrom(ctx context.Context, profileImage string, conf *container.Config, hostconf *container.HostConfig, netconf *network.NetworkingConfig) error {
return c.create(ctx, profileImage, conf, hostconf, netconf)
}
// Create is analogous to 'docker create'.
func (c *Container) Create(ctx context.Context, r RunOpts, args ...string) error {
return c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil)
}
func (c *Container) create(ctx context.Context, profileImage string, conf *container.Config, hostconf *container.HostConfig, netconf *network.NetworkingConfig) error {
if c.runtime != "" && c.runtime != "runc" {
// Use the image name as provided here; which normally represents the
// unmodified "basic/alpine" image name. This should be easy to grok.
c.profileInit(profileImage)
}
cont, err := c.client.ContainerCreate(ctx, conf, hostconf, nil, nil, c.Name)
if err != nil {
return err
}
c.id = cont.ID
return nil
}
func (c *Container) | (r RunOpts, args []string) *container.Config {
ports := nat.PortSet{}
for _, p := range r.Ports {
port := nat.Port(fmt.Sprintf("%d", p))
ports[port] = struct{}{}
}
env := append(r.Env, fmt.Sprintf("RUNSC_TEST_NAME=%s", c.Name))
return &container.Config{
Image: testutil.ImageByName(r.Image),
Cmd: args,
ExposedPorts: ports,
Env: env,
WorkingDir: r.WorkDir,
User: r.User,
}
}
func (c *Container) hostConfig(r RunOpts) *container.HostConfig {
c.mounts = append(c.mounts, r.Mounts...)
return &container.HostConfig{
Runtime: c.runtime,
Mounts: c.mounts,
PublishAllPorts: true,
Links: r.Links,
CapAdd: r.CapAdd,
CapDrop: r.CapDrop,
Privileged: r.Privileged,
ReadonlyRootfs: r.ReadOnly,
NetworkMode: container.NetworkMode(r.NetworkMode),
Resources: container.Resources{
Memory: int64(r.Memory), // In bytes.
CpusetCpus: r.CpusetCpus,
},
}
}
// Start is analogous to 'docker start'.
func (c *Container) Start(ctx context.Context) error {
if err := c.client.ContainerStart(ctx, c.id, types.ContainerStartOptions{}); err != nil {
return fmt.Errorf("ContainerStart failed: %v", err)
}
if c.profile != nil {
if err := c.profile.Start(c); err != nil {
c.logger.Logf("profile.Start failed: %v", err)
}
}
return nil
}
// Stop is analogous to 'docker stop'.
func (c *Container) Stop(ctx context.Context) error {
return c.client.ContainerStop(ctx, c.id, container.StopOptions{})
}
// Pause is analogous to'docker pause'.
func (c *Container) Pause(ctx context.Context) error {
return c.client.ContainerPause(ctx, c.id)
}
// Unpause is analogous to 'docker unpause'.
func (c *Container) Unpause(ctx context.Context) error {
return c.client.ContainerUnpause(ctx, c.id)
}
// Checkpoint is analogous to 'docker checkpoint'.
func (c *Container) Checkpoint(ctx context.Context, name string) error {
return c.client.CheckpointCreate(ctx, c.Name, types.CheckpointCreateOptions{CheckpointID: name, Exit: true})
}
// Restore is analogous to 'docker start --checkname [name]'.
func (c *Container) Restore(ctx context.Context, name string) error {
return c.client.ContainerStart(ctx, c.id, types.ContainerStartOptions{CheckpointID: name})
}
// Logs is analogous 'docker logs'.
func (c *Container) Logs(ctx context.Context) (string, error) {
var out bytes.Buffer
err := c.logs(ctx, &out, &out)
return out.String(), err
}
func (c *Container) logs(ctx context.Context, stdout, stderr *bytes.Buffer) error {
opts := types.ContainerLogsOptions{ShowStdout: true, ShowStderr: true}
writer, err := c.client.ContainerLogs(ctx, c.id, opts)
if err != nil {
return err
}
defer writer.Close()
_, err = stdcopy.StdCopy(stdout, stderr, writer)
return err
}
// ID returns the container id.
func (c *Container) ID() string {
return c.id
}
// RootDirectory returns an educated guess about the container's root directory.
func (c *Container) RootDirectory() (string, error) {
// The root directory of this container's runtime.
rootDir := fmt.Sprintf("/var/run/docker/runtime-%s/moby", c.runtime)
_, err := os.Stat(rootDir)
if err == nil {
return rootDir, nil
}
// In docker v20+, due to https://github.com/moby/moby/issues/42345 the
// rootDir seems to always be the following.
const defaultDir = "/var/run/docker/runtime-runc/moby"
_, derr := os.Stat(defaultDir)
if derr == nil {
return defaultDir, nil
}
return "", fmt.Errorf("cannot stat %q: %v or %q: %v", rootDir, err, defaultDir, derr)
}
// SandboxPid returns the container's pid.
func (c *Container) SandboxPid(ctx context.Context) (int, error) {
resp, err := c.client.ContainerInspect(ctx | config | identifier_name |
container.go | &Container{
logger: logger,
Name: name,
runtime: runtime,
client: client,
}
}
// MakeContainer constructs a suitable Container object.
//
// The runtime used is determined by the runtime flag.
//
// Containers will check flags for profiling requests.
func MakeContainer(ctx context.Context, logger testutil.Logger) *Container {
return makeContainer(ctx, logger, *runtime)
}
// MakeContainerWithRuntime is like MakeContainer, but allows for a runtime
// to be specified by suffix.
func MakeContainerWithRuntime(ctx context.Context, logger testutil.Logger, suffix string) *Container {
return makeContainer(ctx, logger, *runtime+suffix)
}
// MakeNativeContainer constructs a suitable Container object.
//
// The runtime used will be the system default.
//
// Native containers aren't profiled. | return makeContainer(ctx, logger, unsandboxedRuntime)
}
// Spawn is analogous to 'docker run -d'.
func (c *Container) Spawn(ctx context.Context, r RunOpts, args ...string) error {
if err := c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil); err != nil {
return err
}
return c.Start(ctx)
}
// SpawnProcess is analogous to 'docker run -it'. It returns a process
// which represents the root process.
func (c *Container) SpawnProcess(ctx context.Context, r RunOpts, args ...string) (Process, error) {
config, hostconf, netconf := c.ConfigsFrom(r, args...)
config.Tty = true
config.OpenStdin = true
if err := c.CreateFrom(ctx, r.Image, config, hostconf, netconf); err != nil {
return Process{}, err
}
// Open a connection to the container for parsing logs and for TTY.
stream, err := c.client.ContainerAttach(ctx, c.id,
types.ContainerAttachOptions{
Stream: true,
Stdin: true,
Stdout: true,
Stderr: true,
})
if err != nil {
return Process{}, fmt.Errorf("connect failed container id %s: %v", c.id, err)
}
c.cleanups = append(c.cleanups, func() { stream.Close() })
if err := c.Start(ctx); err != nil {
return Process{}, err
}
return Process{container: c, conn: stream}, nil
}
// Run is analogous to 'docker run'.
func (c *Container) Run(ctx context.Context, r RunOpts, args ...string) (string, error) {
if err := c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil); err != nil {
return "", err
}
if err := c.Start(ctx); err != nil {
return "", err
}
if err := c.Wait(ctx); err != nil {
return "", err
}
return c.Logs(ctx)
}
// ConfigsFrom returns container configs from RunOpts and args. The caller should call 'CreateFrom'
// and Start.
func (c *Container) ConfigsFrom(r RunOpts, args ...string) (*container.Config, *container.HostConfig, *network.NetworkingConfig) {
return c.config(r, args), c.hostConfig(r), &network.NetworkingConfig{}
}
// MakeLink formats a link to add to a RunOpts.
func (c *Container) MakeLink(target string) string {
return fmt.Sprintf("%s:%s", c.Name, target)
}
// CreateFrom creates a container from the given configs.
func (c *Container) CreateFrom(ctx context.Context, profileImage string, conf *container.Config, hostconf *container.HostConfig, netconf *network.NetworkingConfig) error {
return c.create(ctx, profileImage, conf, hostconf, netconf)
}
// Create is analogous to 'docker create'.
func (c *Container) Create(ctx context.Context, r RunOpts, args ...string) error {
return c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil)
}
func (c *Container) create(ctx context.Context, profileImage string, conf *container.Config, hostconf *container.HostConfig, netconf *network.NetworkingConfig) error {
if c.runtime != "" && c.runtime != "runc" {
// Use the image name as provided here; which normally represents the
// unmodified "basic/alpine" image name. This should be easy to grok.
c.profileInit(profileImage)
}
cont, err := c.client.ContainerCreate(ctx, conf, hostconf, nil, nil, c.Name)
if err != nil {
return err
}
c.id = cont.ID
return nil
}
func (c *Container) config(r RunOpts, args []string) *container.Config {
ports := nat.PortSet{}
for _, p := range r.Ports {
port := nat.Port(fmt.Sprintf("%d", p))
ports[port] = struct{}{}
}
env := append(r.Env, fmt.Sprintf("RUNSC_TEST_NAME=%s", c.Name))
return &container.Config{
Image: testutil.ImageByName(r.Image),
Cmd: args,
ExposedPorts: ports,
Env: env,
WorkingDir: r.WorkDir,
User: r.User,
}
}
func (c *Container) hostConfig(r RunOpts) *container.HostConfig {
c.mounts = append(c.mounts, r.Mounts...)
return &container.HostConfig{
Runtime: c.runtime,
Mounts: c.mounts,
PublishAllPorts: true,
Links: r.Links,
CapAdd: r.CapAdd,
CapDrop: r.CapDrop,
Privileged: r.Privileged,
ReadonlyRootfs: r.ReadOnly,
NetworkMode: container.NetworkMode(r.NetworkMode),
Resources: container.Resources{
Memory: int64(r.Memory), // In bytes.
CpusetCpus: r.CpusetCpus,
},
}
}
// Start is analogous to 'docker start'.
func (c *Container) Start(ctx context.Context) error {
if err := c.client.ContainerStart(ctx, c.id, types.ContainerStartOptions{}); err != nil {
return fmt.Errorf("ContainerStart failed: %v", err)
}
if c.profile != nil {
if err := c.profile.Start(c); err != nil {
c.logger.Logf("profile.Start failed: %v", err)
}
}
return nil
}
// Stop is analogous to 'docker stop'.
func (c *Container) Stop(ctx context.Context) error {
return c.client.ContainerStop(ctx, c.id, container.StopOptions{})
}
// Pause is analogous to'docker pause'.
func (c *Container) Pause(ctx context.Context) error {
return c.client.ContainerPause(ctx, c.id)
}
// Unpause is analogous to 'docker unpause'.
func (c *Container) Unpause(ctx context.Context) error {
return c.client.ContainerUnpause(ctx, c.id)
}
// Checkpoint is analogous to 'docker checkpoint'.
func (c *Container) Checkpoint(ctx context.Context, name string) error {
return c.client.CheckpointCreate(ctx, c.Name, types.CheckpointCreateOptions{CheckpointID: name, Exit: true})
}
// Restore is analogous to 'docker start --checkname [name]'.
func (c *Container) Restore(ctx context.Context, name string) error {
return c.client.ContainerStart(ctx, c.id, types.ContainerStartOptions{CheckpointID: name})
}
// Logs is analogous 'docker logs'.
func (c *Container) Logs(ctx context.Context) (string, error) {
var out bytes.Buffer
err := c.logs(ctx, &out, &out)
return out.String(), err
}
func (c *Container) logs(ctx context.Context, stdout, stderr *bytes.Buffer) error {
opts := types.ContainerLogsOptions{ShowStdout: true, ShowStderr: true}
writer, err := c.client.ContainerLogs(ctx, c.id, opts)
if err != nil {
return err
}
defer writer.Close()
_, err = stdcopy.StdCopy(stdout, stderr, writer)
return err
}
// ID returns the container id.
func (c *Container) ID() string {
return c.id
}
// RootDirectory returns an educated guess about the container's root directory.
func (c *Container) RootDirectory() (string, error) {
// The root directory of this container's runtime.
rootDir := fmt.Sprintf("/var/run/docker/runtime-%s/moby", c.runtime)
_, err := os.Stat(rootDir)
if err == nil {
return rootDir, nil
}
// In docker v20+, due to https://github.com/moby/moby/issues/42345 the
// rootDir seems to always be the following.
const defaultDir = "/var/run/docker/runtime-runc/moby"
_, derr := os.Stat(defaultDir)
if derr == nil {
return defaultDir, nil
}
return "", fmt.Errorf("cannot stat %q: %v or %q: %v", rootDir, err, defaultDir, derr)
}
// SandboxPid returns the container's pid.
func (c *Container) SandboxPid(ctx context.Context) (int, error) {
resp, err := c.client.ContainerInspect(ctx, | func MakeNativeContainer(ctx context.Context, logger testutil.Logger) *Container {
unsandboxedRuntime := "runc"
if override, found := os.LookupEnv("UNSANDBOXED_RUNTIME"); found {
unsandboxedRuntime = override
} | random_line_split |
container.go | Container{
logger: logger,
Name: name,
runtime: runtime,
client: client,
}
}
// MakeContainer constructs a suitable Container object.
//
// The runtime used is determined by the runtime flag.
//
// Containers will check flags for profiling requests.
func MakeContainer(ctx context.Context, logger testutil.Logger) *Container {
return makeContainer(ctx, logger, *runtime)
}
// MakeContainerWithRuntime is like MakeContainer, but allows for a runtime
// to be specified by suffix.
func MakeContainerWithRuntime(ctx context.Context, logger testutil.Logger, suffix string) *Container {
return makeContainer(ctx, logger, *runtime+suffix)
}
// MakeNativeContainer constructs a suitable Container object.
//
// The runtime used will be the system default.
//
// Native containers aren't profiled.
func MakeNativeContainer(ctx context.Context, logger testutil.Logger) *Container {
unsandboxedRuntime := "runc"
if override, found := os.LookupEnv("UNSANDBOXED_RUNTIME"); found {
unsandboxedRuntime = override
}
return makeContainer(ctx, logger, unsandboxedRuntime)
}
// Spawn is analogous to 'docker run -d'.
func (c *Container) Spawn(ctx context.Context, r RunOpts, args ...string) error {
if err := c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil); err != nil {
return err
}
return c.Start(ctx)
}
// SpawnProcess is analogous to 'docker run -it'. It returns a process
// which represents the root process.
func (c *Container) SpawnProcess(ctx context.Context, r RunOpts, args ...string) (Process, error) {
config, hostconf, netconf := c.ConfigsFrom(r, args...)
config.Tty = true
config.OpenStdin = true
if err := c.CreateFrom(ctx, r.Image, config, hostconf, netconf); err != nil {
return Process{}, err
}
// Open a connection to the container for parsing logs and for TTY.
stream, err := c.client.ContainerAttach(ctx, c.id,
types.ContainerAttachOptions{
Stream: true,
Stdin: true,
Stdout: true,
Stderr: true,
})
if err != nil {
return Process{}, fmt.Errorf("connect failed container id %s: %v", c.id, err)
}
c.cleanups = append(c.cleanups, func() { stream.Close() })
if err := c.Start(ctx); err != nil {
return Process{}, err
}
return Process{container: c, conn: stream}, nil
}
// Run is analogous to 'docker run'.
func (c *Container) Run(ctx context.Context, r RunOpts, args ...string) (string, error) {
if err := c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil); err != nil {
return "", err
}
if err := c.Start(ctx); err != nil {
return "", err
}
if err := c.Wait(ctx); err != nil {
return "", err
}
return c.Logs(ctx)
}
// ConfigsFrom returns container configs from RunOpts and args. The caller should call 'CreateFrom'
// and Start.
func (c *Container) ConfigsFrom(r RunOpts, args ...string) (*container.Config, *container.HostConfig, *network.NetworkingConfig) {
return c.config(r, args), c.hostConfig(r), &network.NetworkingConfig{}
}
// MakeLink formats a link to add to a RunOpts.
func (c *Container) MakeLink(target string) string {
return fmt.Sprintf("%s:%s", c.Name, target)
}
// CreateFrom creates a container from the given configs.
func (c *Container) CreateFrom(ctx context.Context, profileImage string, conf *container.Config, hostconf *container.HostConfig, netconf *network.NetworkingConfig) error {
return c.create(ctx, profileImage, conf, hostconf, netconf)
}
// Create is analogous to 'docker create'.
func (c *Container) Create(ctx context.Context, r RunOpts, args ...string) error {
return c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil)
}
func (c *Container) create(ctx context.Context, profileImage string, conf *container.Config, hostconf *container.HostConfig, netconf *network.NetworkingConfig) error {
if c.runtime != "" && c.runtime != "runc" {
// Use the image name as provided here; which normally represents the
// unmodified "basic/alpine" image name. This should be easy to grok.
c.profileInit(profileImage)
}
cont, err := c.client.ContainerCreate(ctx, conf, hostconf, nil, nil, c.Name)
if err != nil {
return err
}
c.id = cont.ID
return nil
}
func (c *Container) config(r RunOpts, args []string) *container.Config {
ports := nat.PortSet{}
for _, p := range r.Ports {
port := nat.Port(fmt.Sprintf("%d", p))
ports[port] = struct{}{}
}
env := append(r.Env, fmt.Sprintf("RUNSC_TEST_NAME=%s", c.Name))
return &container.Config{
Image: testutil.ImageByName(r.Image),
Cmd: args,
ExposedPorts: ports,
Env: env,
WorkingDir: r.WorkDir,
User: r.User,
}
}
func (c *Container) hostConfig(r RunOpts) *container.HostConfig {
c.mounts = append(c.mounts, r.Mounts...)
return &container.HostConfig{
Runtime: c.runtime,
Mounts: c.mounts,
PublishAllPorts: true,
Links: r.Links,
CapAdd: r.CapAdd,
CapDrop: r.CapDrop,
Privileged: r.Privileged,
ReadonlyRootfs: r.ReadOnly,
NetworkMode: container.NetworkMode(r.NetworkMode),
Resources: container.Resources{
Memory: int64(r.Memory), // In bytes.
CpusetCpus: r.CpusetCpus,
},
}
}
// Start is analogous to 'docker start'.
func (c *Container) Start(ctx context.Context) error {
if err := c.client.ContainerStart(ctx, c.id, types.ContainerStartOptions{}); err != nil {
return fmt.Errorf("ContainerStart failed: %v", err)
}
if c.profile != nil |
return nil
}
// Stop is analogous to 'docker stop'.
func (c *Container) Stop(ctx context.Context) error {
return c.client.ContainerStop(ctx, c.id, container.StopOptions{})
}
// Pause is analogous to'docker pause'.
func (c *Container) Pause(ctx context.Context) error {
return c.client.ContainerPause(ctx, c.id)
}
// Unpause is analogous to 'docker unpause'.
func (c *Container) Unpause(ctx context.Context) error {
return c.client.ContainerUnpause(ctx, c.id)
}
// Checkpoint is analogous to 'docker checkpoint'.
func (c *Container) Checkpoint(ctx context.Context, name string) error {
return c.client.CheckpointCreate(ctx, c.Name, types.CheckpointCreateOptions{CheckpointID: name, Exit: true})
}
// Restore is analogous to 'docker start --checkname [name]'.
func (c *Container) Restore(ctx context.Context, name string) error {
return c.client.ContainerStart(ctx, c.id, types.ContainerStartOptions{CheckpointID: name})
}
// Logs is analogous 'docker logs'.
func (c *Container) Logs(ctx context.Context) (string, error) {
var out bytes.Buffer
err := c.logs(ctx, &out, &out)
return out.String(), err
}
func (c *Container) logs(ctx context.Context, stdout, stderr *bytes.Buffer) error {
opts := types.ContainerLogsOptions{ShowStdout: true, ShowStderr: true}
writer, err := c.client.ContainerLogs(ctx, c.id, opts)
if err != nil {
return err
}
defer writer.Close()
_, err = stdcopy.StdCopy(stdout, stderr, writer)
return err
}
// ID returns the container id.
func (c *Container) ID() string {
return c.id
}
// RootDirectory returns an educated guess about the container's root directory.
func (c *Container) RootDirectory() (string, error) {
// The root directory of this container's runtime.
rootDir := fmt.Sprintf("/var/run/docker/runtime-%s/moby", c.runtime)
_, err := os.Stat(rootDir)
if err == nil {
return rootDir, nil
}
// In docker v20+, due to https://github.com/moby/moby/issues/42345 the
// rootDir seems to always be the following.
const defaultDir = "/var/run/docker/runtime-runc/moby"
_, derr := os.Stat(defaultDir)
if derr == nil {
return defaultDir, nil
}
return "", fmt.Errorf("cannot stat %q: %v or %q: %v", rootDir, err, defaultDir, derr)
}
// SandboxPid returns the container's pid.
func (c *Container) SandboxPid(ctx context.Context) (int, error) {
resp, err := c.client.ContainerInspect(ctx | {
if err := c.profile.Start(c); err != nil {
c.logger.Logf("profile.Start failed: %v", err)
}
} | conditional_block |
container.go | Container{
logger: logger,
Name: name,
runtime: runtime,
client: client,
}
}
// MakeContainer constructs a suitable Container object.
//
// The runtime used is determined by the runtime flag.
//
// Containers will check flags for profiling requests.
func MakeContainer(ctx context.Context, logger testutil.Logger) *Container {
return makeContainer(ctx, logger, *runtime)
}
// MakeContainerWithRuntime is like MakeContainer, but allows for a runtime
// to be specified by suffix.
func MakeContainerWithRuntime(ctx context.Context, logger testutil.Logger, suffix string) *Container {
return makeContainer(ctx, logger, *runtime+suffix)
}
// MakeNativeContainer constructs a suitable Container object.
//
// The runtime used will be the system default.
//
// Native containers aren't profiled.
func MakeNativeContainer(ctx context.Context, logger testutil.Logger) *Container {
unsandboxedRuntime := "runc"
if override, found := os.LookupEnv("UNSANDBOXED_RUNTIME"); found {
unsandboxedRuntime = override
}
return makeContainer(ctx, logger, unsandboxedRuntime)
}
// Spawn is analogous to 'docker run -d'.
func (c *Container) Spawn(ctx context.Context, r RunOpts, args ...string) error {
if err := c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil); err != nil {
return err
}
return c.Start(ctx)
}
// SpawnProcess is analogous to 'docker run -it'. It returns a process
// which represents the root process.
func (c *Container) SpawnProcess(ctx context.Context, r RunOpts, args ...string) (Process, error) {
config, hostconf, netconf := c.ConfigsFrom(r, args...)
config.Tty = true
config.OpenStdin = true
if err := c.CreateFrom(ctx, r.Image, config, hostconf, netconf); err != nil {
return Process{}, err
}
// Open a connection to the container for parsing logs and for TTY.
stream, err := c.client.ContainerAttach(ctx, c.id,
types.ContainerAttachOptions{
Stream: true,
Stdin: true,
Stdout: true,
Stderr: true,
})
if err != nil {
return Process{}, fmt.Errorf("connect failed container id %s: %v", c.id, err)
}
c.cleanups = append(c.cleanups, func() { stream.Close() })
if err := c.Start(ctx); err != nil {
return Process{}, err
}
return Process{container: c, conn: stream}, nil
}
// Run is analogous to 'docker run'.
func (c *Container) Run(ctx context.Context, r RunOpts, args ...string) (string, error) {
if err := c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil); err != nil {
return "", err
}
if err := c.Start(ctx); err != nil {
return "", err
}
if err := c.Wait(ctx); err != nil {
return "", err
}
return c.Logs(ctx)
}
// ConfigsFrom returns container configs from RunOpts and args. The caller should call 'CreateFrom'
// and Start.
func (c *Container) ConfigsFrom(r RunOpts, args ...string) (*container.Config, *container.HostConfig, *network.NetworkingConfig) {
return c.config(r, args), c.hostConfig(r), &network.NetworkingConfig{}
}
// MakeLink formats a link to add to a RunOpts.
func (c *Container) MakeLink(target string) string {
return fmt.Sprintf("%s:%s", c.Name, target)
}
// CreateFrom creates a container from the given configs.
func (c *Container) CreateFrom(ctx context.Context, profileImage string, conf *container.Config, hostconf *container.HostConfig, netconf *network.NetworkingConfig) error {
return c.create(ctx, profileImage, conf, hostconf, netconf)
}
// Create is analogous to 'docker create'.
func (c *Container) Create(ctx context.Context, r RunOpts, args ...string) error {
return c.create(ctx, r.Image, c.config(r, args), c.hostConfig(r), nil)
}
func (c *Container) create(ctx context.Context, profileImage string, conf *container.Config, hostconf *container.HostConfig, netconf *network.NetworkingConfig) error {
if c.runtime != "" && c.runtime != "runc" {
// Use the image name as provided here; which normally represents the
// unmodified "basic/alpine" image name. This should be easy to grok.
c.profileInit(profileImage)
}
cont, err := c.client.ContainerCreate(ctx, conf, hostconf, nil, nil, c.Name)
if err != nil {
return err
}
c.id = cont.ID
return nil
}
func (c *Container) config(r RunOpts, args []string) *container.Config {
ports := nat.PortSet{}
for _, p := range r.Ports {
port := nat.Port(fmt.Sprintf("%d", p))
ports[port] = struct{}{}
}
env := append(r.Env, fmt.Sprintf("RUNSC_TEST_NAME=%s", c.Name))
return &container.Config{
Image: testutil.ImageByName(r.Image),
Cmd: args,
ExposedPorts: ports,
Env: env,
WorkingDir: r.WorkDir,
User: r.User,
}
}
func (c *Container) hostConfig(r RunOpts) *container.HostConfig {
c.mounts = append(c.mounts, r.Mounts...)
return &container.HostConfig{
Runtime: c.runtime,
Mounts: c.mounts,
PublishAllPorts: true,
Links: r.Links,
CapAdd: r.CapAdd,
CapDrop: r.CapDrop,
Privileged: r.Privileged,
ReadonlyRootfs: r.ReadOnly,
NetworkMode: container.NetworkMode(r.NetworkMode),
Resources: container.Resources{
Memory: int64(r.Memory), // In bytes.
CpusetCpus: r.CpusetCpus,
},
}
}
// Start is analogous to 'docker start'.
func (c *Container) Start(ctx context.Context) error {
if err := c.client.ContainerStart(ctx, c.id, types.ContainerStartOptions{}); err != nil {
return fmt.Errorf("ContainerStart failed: %v", err)
}
if c.profile != nil {
if err := c.profile.Start(c); err != nil {
c.logger.Logf("profile.Start failed: %v", err)
}
}
return nil
}
// Stop is analogous to 'docker stop'.
func (c *Container) Stop(ctx context.Context) error {
return c.client.ContainerStop(ctx, c.id, container.StopOptions{})
}
// Pause is analogous to'docker pause'.
func (c *Container) Pause(ctx context.Context) error {
return c.client.ContainerPause(ctx, c.id)
}
// Unpause is analogous to 'docker unpause'.
func (c *Container) Unpause(ctx context.Context) error {
return c.client.ContainerUnpause(ctx, c.id)
}
// Checkpoint is analogous to 'docker checkpoint'.
func (c *Container) Checkpoint(ctx context.Context, name string) error {
return c.client.CheckpointCreate(ctx, c.Name, types.CheckpointCreateOptions{CheckpointID: name, Exit: true})
}
// Restore is analogous to 'docker start --checkname [name]'.
func (c *Container) Restore(ctx context.Context, name string) error {
return c.client.ContainerStart(ctx, c.id, types.ContainerStartOptions{CheckpointID: name})
}
// Logs is analogous 'docker logs'.
func (c *Container) Logs(ctx context.Context) (string, error) {
var out bytes.Buffer
err := c.logs(ctx, &out, &out)
return out.String(), err
}
func (c *Container) logs(ctx context.Context, stdout, stderr *bytes.Buffer) error {
opts := types.ContainerLogsOptions{ShowStdout: true, ShowStderr: true}
writer, err := c.client.ContainerLogs(ctx, c.id, opts)
if err != nil {
return err
}
defer writer.Close()
_, err = stdcopy.StdCopy(stdout, stderr, writer)
return err
}
// ID returns the container id.
func (c *Container) ID() string |
// RootDirectory returns an educated guess about the container's root directory.
func (c *Container) RootDirectory() (string, error) {
// The root directory of this container's runtime.
rootDir := fmt.Sprintf("/var/run/docker/runtime-%s/moby", c.runtime)
_, err := os.Stat(rootDir)
if err == nil {
return rootDir, nil
}
// In docker v20+, due to https://github.com/moby/moby/issues/42345 the
// rootDir seems to always be the following.
const defaultDir = "/var/run/docker/runtime-runc/moby"
_, derr := os.Stat(defaultDir)
if derr == nil {
return defaultDir, nil
}
return "", fmt.Errorf("cannot stat %q: %v or %q: %v", rootDir, err, defaultDir, derr)
}
// SandboxPid returns the container's pid.
func (c *Container) SandboxPid(ctx context.Context) (int, error) {
resp, err := c.client.ContainerInspect(ctx | {
return c.id
} | identifier_body |
combine.py |
# If nothing was found then don't continue, this can happen if no mp4 files are found or if only the joined file is found
if( len(file_infos) <= 0 ):
print( "No mp4 video files found matching '{0}'".format(args.match))
sys.exit(0)
print("Found {0} files".format(len(file_infos)))
# If the user supplied a cut point information file then we parse it now
cuts = None
if( args.cuts ):
cuts = parseCutPointInformation(Path(args.cuts))
print(cuts)
if not cuts is None:
print("Read {0} cut point data from cut file".format(len(cuts)))
# If the user wants the list of files shuffled then do that now in place
if( args.shuffle ):
shuffle(file_infos)
print("File list shuffled")
# Now create the list of files to create
video_files = []
chapters = []
cumulative_dur = timedelta(seconds=0)
cumulative_size = 0
# Collect the file info data and chapter points for all files
for file_info in file_infos:
file_name = Path(file_info['file']).name
video_files.append(file_info['file'])
file_info_dur = file_info['dur']
# Do we have a proposed cut duration, if so then we must use this info
# to correct the chapter locations
if not cuts is None and file_name in cuts and 't' in cuts[file_name]:
file_info_dur = timedelta(seconds=cuts[file_name]['t'])
chapters.append({"name": Path(file_info['file']).stem, "timecode":formatTimedelta(cumulative_dur)})
cumulative_dur += file_info_dur # Count the cumulative duration
cumulative_size += file_info['size']
createCombinedVideoFile(video_files, chapters, cumulative_dur, cumulative_size, mp4exec, ffmpegexec, path_out_file, path_chapters_file, args.overwrite, cuts, args.videosize, args.burnsubs, max_out_size_kb, args.noaudio )
print(Colors.success("Script completed successfully, bye!"))
finally:
deinit() #Deinitialize the colorama library
# Reads and parses cut information for the input files
def parseCutPointInformation(path_to_cuts_file):
cuts = {}
with open(str(path_to_cuts_file), encoding='utf-8') as csvfile:
row_reader = csv.reader(csvfile)
for row in row_reader:
if( len(row) < 2 ):
continue
filename = row[0].strip()
# Create a new entry for the file
cuts[filename] = {}
starttime = row[1].strip()
cuts[filename]['ss'] = starttime
startpoint = sum(x * int(t) for x, t in zip([1, 60, 3600], reversed(starttime.split(":"))))
if len(row) > 2:
timecode = row[2].strip()
fullduration = sum(x * int(t) for x, t in zip([1, 60, 3600], reversed(timecode.split(":"))))
cuts[filename]['t'] = fullduration - startpoint
if len(cuts) <= 0:
return None
return cuts
#
# Creates a combined video file for a segment
def createCombinedVideoFile(video_files, chapters, cumulative_dur, cumulative_size, mp4exec, ffmpegexec, path_out_file, path_chapters_file, args_overwrite, cuts, args_videomaxsize, args_burnsubs, max_out_size_kb=0, args_noaudio=False ):
print( "Output: {0}".format(Colors.fileout(str(path_out_file))))
# Add the final chapter as the end for this segment
chapters.append({"name": "End", "timecode":formatTimedelta(cumulative_dur)})
# Chapters should be +1 more than files as we have an extra chapter ending at the very end of the file
print("{0} chapters, {1} running time, {2} total size".format( len(chapters), formatTimedelta(cumulative_dur), humanize.naturalsize(cumulative_size, gnu=True)))
# Write the chapters file to out
saveChaptersFile(chapters, path_chapters_file)
# Re-encode and combine the video files first
print(Colors.toolpath("Combining and re-encoding video files (ffmpeg), this will take a while..."))
reencodeAndCombineVideoFiles(ffmpegexec, video_files, path_out_file, args_videomaxsize, cuts, args_burnsubs, args_noaudio)
# Now create the combined file and include the chapter marks
print(Colors.toolpath("Adding chapters to combined video file (mp4box)"))
addChaptersToVideoFile(mp4exec, path_out_file, path_chapters_file)
# Delete the chapters file
os.remove(str(path_chapters_file))
# Read the created file to learn its final filesize
size_out_file_kb = os.path.getsize(str(path_out_file)) / 1024
print( Colors.toolpath("Final size of video file is: {0}".format(humanize.naturalsize(size_out_file_kb * 1024))))
# Now split the file if requested
if max_out_size_kb > 0 and size_out_file_kb > max_out_size_kb :
print( Colors.toolpath("Size limit exceeded, splitting video into files of max size: {0}".format(humanize.naturalsize(max_out_size_kb * 1000))))
splitVideoFile(mp4exec, path_out_file, max_out_size_kb)
#
# Attempts to detect the requested size of the output file based on the input parameters
# the absolute_size is overridden by disk_capacity if both are specified
# Returns KB (kilobytes)
def determineMaximumOutputfileSizeInKb(absolute_size, disk_capacity):
if( disk_capacity and disk_capacity in DISKSIZES ):
dsk_cap = DISKSIZES[disk_capacity]
#print( "Disk Capacity: {0}".format(dsk_cap))
return dsk_cap
elif( absolute_size):
#print( "Absolute size: "+absolute_size)
# First remove all spaces from the size string and convert to uppercase, remove all commas from the string
# now attempt to parse the sizes
abs_size = "".join("".join(absolute_size.split(' ')).split(',')).upper()
regex_size_parse = re.compile(r"^(?P<size>[0-9]*(?:\.[0-9]*)?)\s*(?P<unit>GB|MB|KB|B|TB)?$", re.MULTILINE)
match = regex_size_parse.search( absolute_size )
size = float(match.group("size"))
unit = match.group("unit")
#print( "Absolute value: {0}, unit: {1} ".format(size, unit))
if( not unit or not unit in ABSSIZES ):
unit = "MB" # Default is megabytes if nothing is specified
unit_multiplier = ABSSIZES[unit]
total_size = size * unit_multiplier
#print( "Absolute total: {0}, mult: {1} ".format(total_size, unit_multiplier))
return total_size / 1000 # Return kilobytes but in the metric system sense not the "1024 byte sense"
else:
# If nothing is specified then the default return is to use unbounded
return -1
#
# Executes the mp4box app with the -info switch and
# extracts the track length and file size from the output
def parseMp4boxMediaInfo(file_name, mp4box_path, regex_mp4box_duration):
# Get the size of the file in bytes
statinfo = os.stat(file_name)
file_size = statinfo.st_size #Size in bytes of a plain file
# Run the app and collect the output
proc_cmd = [mp4box_path, "-info", "-std", file_name]
ret = subprocess.run(proc_cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
# Ensure that the return code was ok before continuing
if ret.returncode != 0:
print("Command {0} returned non-zero exit status {1}.".format(proc_cmd, ret.returncode))
print("File {0} will be skipped".format(file_name))
return None
#ret.check_returncode()
# Computed Duration 00:23:06.040 - Indicated Duration 00:23:06.040
match = regex_mp4box_duration.search( ret.stdout )
hrs = int(match.group("hrs"))
min = int(match.group("min"))
sec = int(match.group("sec"))
msec = int(match.group("msec"))
duration = timedelta(days=0, hours=hrs, minutes=min, seconds=sec, milliseconds=msec )
return {'file':file_name, 'size':file_size, 'dur':duration }
#
# Locates the mp4box executable and returns a full path to it
def findMp4Box(path_to_gpac_install=None, working_dir=None):
if( not path_to_gpac_install is None and os.path.isfile(os.path.join(path_to_gpac_install, "mp4box.exe | file_infos.append(m4b_fileinfo) | conditional_block | |
combine.py | dur']
# Do we have a proposed cut duration, if so then we must use this info
# to correct the chapter locations
if not cuts is None and file_name in cuts and 't' in cuts[file_name]:
file_info_dur = timedelta(seconds=cuts[file_name]['t'])
chapters.append({"name": Path(file_info['file']).stem, "timecode":formatTimedelta(cumulative_dur)})
cumulative_dur += file_info_dur # Count the cumulative duration
cumulative_size += file_info['size']
createCombinedVideoFile(video_files, chapters, cumulative_dur, cumulative_size, mp4exec, ffmpegexec, path_out_file, path_chapters_file, args.overwrite, cuts, args.videosize, args.burnsubs, max_out_size_kb, args.noaudio )
print(Colors.success("Script completed successfully, bye!"))
finally:
deinit() #Deinitialize the colorama library
# Reads and parses cut information for the input files
def parseCutPointInformation(path_to_cuts_file):
cuts = {}
with open(str(path_to_cuts_file), encoding='utf-8') as csvfile:
row_reader = csv.reader(csvfile)
for row in row_reader:
if( len(row) < 2 ):
continue
filename = row[0].strip()
# Create a new entry for the file
cuts[filename] = {}
starttime = row[1].strip()
cuts[filename]['ss'] = starttime
startpoint = sum(x * int(t) for x, t in zip([1, 60, 3600], reversed(starttime.split(":"))))
if len(row) > 2:
timecode = row[2].strip()
fullduration = sum(x * int(t) for x, t in zip([1, 60, 3600], reversed(timecode.split(":"))))
cuts[filename]['t'] = fullduration - startpoint
if len(cuts) <= 0:
return None
return cuts
#
# Creates a combined video file for a segment
def createCombinedVideoFile(video_files, chapters, cumulative_dur, cumulative_size, mp4exec, ffmpegexec, path_out_file, path_chapters_file, args_overwrite, cuts, args_videomaxsize, args_burnsubs, max_out_size_kb=0, args_noaudio=False ):
print( "Output: {0}".format(Colors.fileout(str(path_out_file))))
# Add the final chapter as the end for this segment
chapters.append({"name": "End", "timecode":formatTimedelta(cumulative_dur)})
# Chapters should be +1 more than files as we have an extra chapter ending at the very end of the file
print("{0} chapters, {1} running time, {2} total size".format( len(chapters), formatTimedelta(cumulative_dur), humanize.naturalsize(cumulative_size, gnu=True)))
# Write the chapters file to out
saveChaptersFile(chapters, path_chapters_file)
# Re-encode and combine the video files first
print(Colors.toolpath("Combining and re-encoding video files (ffmpeg), this will take a while..."))
reencodeAndCombineVideoFiles(ffmpegexec, video_files, path_out_file, args_videomaxsize, cuts, args_burnsubs, args_noaudio)
# Now create the combined file and include the chapter marks
print(Colors.toolpath("Adding chapters to combined video file (mp4box)"))
addChaptersToVideoFile(mp4exec, path_out_file, path_chapters_file)
# Delete the chapters file
os.remove(str(path_chapters_file))
# Read the created file to learn its final filesize
size_out_file_kb = os.path.getsize(str(path_out_file)) / 1024
print( Colors.toolpath("Final size of video file is: {0}".format(humanize.naturalsize(size_out_file_kb * 1024))))
# Now split the file if requested
if max_out_size_kb > 0 and size_out_file_kb > max_out_size_kb :
print( Colors.toolpath("Size limit exceeded, splitting video into files of max size: {0}".format(humanize.naturalsize(max_out_size_kb * 1000))))
splitVideoFile(mp4exec, path_out_file, max_out_size_kb)
#
# Attempts to detect the requested size of the output file based on the input parameters
# the absolute_size is overridden by disk_capacity if both are specified
# Returns KB (kilobytes)
def determineMaximumOutputfileSizeInKb(absolute_size, disk_capacity):
if( disk_capacity and disk_capacity in DISKSIZES ):
dsk_cap = DISKSIZES[disk_capacity]
#print( "Disk Capacity: {0}".format(dsk_cap))
return dsk_cap
elif( absolute_size):
#print( "Absolute size: "+absolute_size)
# First remove all spaces from the size string and convert to uppercase, remove all commas from the string
# now attempt to parse the sizes
abs_size = "".join("".join(absolute_size.split(' ')).split(',')).upper()
regex_size_parse = re.compile(r"^(?P<size>[0-9]*(?:\.[0-9]*)?)\s*(?P<unit>GB|MB|KB|B|TB)?$", re.MULTILINE)
match = regex_size_parse.search( absolute_size )
size = float(match.group("size"))
unit = match.group("unit")
#print( "Absolute value: {0}, unit: {1} ".format(size, unit))
if( not unit or not unit in ABSSIZES ):
unit = "MB" # Default is megabytes if nothing is specified
unit_multiplier = ABSSIZES[unit]
total_size = size * unit_multiplier
#print( "Absolute total: {0}, mult: {1} ".format(total_size, unit_multiplier))
return total_size / 1000 # Return kilobytes but in the metric system sense not the "1024 byte sense"
else:
# If nothing is specified then the default return is to use unbounded
return -1
#
# Executes the mp4box app with the -info switch and
# extracts the track length and file size from the output
def parseMp4boxMediaInfo(file_name, mp4box_path, regex_mp4box_duration):
# Get the size of the file in bytes
statinfo = os.stat(file_name)
file_size = statinfo.st_size #Size in bytes of a plain file
# Run the app and collect the output
proc_cmd = [mp4box_path, "-info", "-std", file_name]
ret = subprocess.run(proc_cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
# Ensure that the return code was ok before continuing
if ret.returncode != 0: | print("Command {0} returned non-zero exit status {1}.".format(proc_cmd, ret.returncode))
print("File {0} will be skipped".format(file_name))
return None
#ret.check_returncode()
# Computed Duration 00:23:06.040 - Indicated Duration 00:23:06.040
match = regex_mp4box_duration.search( ret.stdout )
hrs = int(match.group("hrs"))
min = int(match.group("min"))
sec = int(match.group("sec"))
msec = int(match.group("msec"))
duration = timedelta(days=0, hours=hrs, minutes=min, seconds=sec, milliseconds=msec )
return {'file':file_name, 'size':file_size, 'dur':duration }
#
# Locates the mp4box executable and returns a full path to it
def findMp4Box(path_to_gpac_install=None, working_dir=None):
if( not path_to_gpac_install is None and os.path.isfile(os.path.join(path_to_gpac_install, "mp4box.exe")) ):
return os.path.join(path_to_gpac_install, "mp4box.exe")
# Attempts to search for it under the bin folder
bin_dist = os.path.join(working_dir, "..\\bin\\GPAC\\mp4box.exe")
if( os.path.isfile(bin_dist)):
return str(Path(bin_dist).resolve())
# Attempts to search for it under C:\Program Files\GPAC
if( os.path.isfile("C:\\Program Files\\GPAC\\mp4box.exe")):
return "C:\\Program Files\\GPAC\\mp4box.exe"
# For 32 bit installs
if( os.path.isfile("C:\\Program Files\\GPAC\\mp4box.exe")):
return "C:\\Program Files (x86)\\GPAC\\mp4box.exe"
# Throw an error
raise ValueError('Could not locate GPAC install, please use the --gpac switch to specify the path to the mp4box.exe file on your system.')
#
# Locates the ffmpeg executable and returns a full path to it
def findffmpeg(path_to_ffmpeg_install=None, working_dir=None):
if( not path_to_ffmpeg_install is None and os.path.isfile(os.path.join(path_to_ffmpeg_install, "ffmpeg.exe")) ):
return os.path.join(path_to_ffmpeg | random_line_split | |
combine.py | error
raise ValueError('Could not locate FFMPEG install, please use the --ffmpeg switch to specify the path to the ffmpeg.exe file on your system.')
#
# Returns an array of files matching the grep string passed in
def getFileNamesFromGrepMatch(grep_match, path_out_file):
in_files = glob.glob(grep_match.replace("\\", "/"))
return [f for f in sorted(in_files, key=natural_key) if '.mp4' in Path(f).suffix and not Path(f) == path_out_file]
#
# Cleans any invalid file name and file path characters from the given filename
def sanitizeFileName(local_filename, sep=" "):
#These are symbols that are not "kosher" on a NTFS filesystem.
local_filename = re.sub(r"[\"/:<>|?*\n\r\t\x00]", sep, local_filename)
return local_filename
#
# Creates a nice format of a datetime.timedelta structure, including milliseconds
def formatTimedelta(time_delta):
timecode_s = time_delta.seconds
timecode_ms = int(time_delta.microseconds / 1000)
return '{:02}:{:02}:{:02}.{:03}'.format(timecode_s // 3600, timecode_s % 3600 // 60, timecode_s % 60, timecode_ms)
#
# Saves a list of chapter information to a chapter file in the common chapter syntax
def saveChaptersFile( chapters, path_chapters_file):
# Make sure that the directory exists and then write the full list of pids to it
if not path_chapters_file.parent.exists():
path_chapters_file.parent.mkdir(parents=True, exist_ok=True)
# If the chapters file is already there, delete it
if os.path.exists(str(path_chapters_file)):
os.remove(str(path_chapters_file))
# Writing the common CHAPTER syntax
# Common syntax : CHAPTERX=h:m:s[:ms or .ms] on one line and CHAPTERXNAME=name on the other – the order is not important but chapter lines MUST be declared sequencially (same X value expected for 2 consecutive lines).
chapter_idx = 1
with path_chapters_file.open(mode='w+', encoding='utf-8') as theFile:
for chapter in chapters:
theFile.write("CHAPTER{0}={1}\n".format(chapter_idx, chapter['timecode']))
theFile.write("CHAPTER{0}NAME=\"{1}\"\n".format(chapter_idx, chapter['name']))
chapter_idx += 1
#
# Executes FFMPEG for all video files to be joined and reencodes
def reencodeAndCombineVideoFiles(ffmpeg_path, video_files, path_out_file, args_videomaxsize, cuts, args_burnsubs, args_noaudio ):
# Construct the args to ffmpeg
# See https://stackoverflow.com/a/26366762/779521
prog_args = [ffmpeg_path]
# How many video files
video_count = len(video_files)
# Is sound enabled
audio_is_enabled = True if not args_noaudio is True else False
# The filter complex configuration
filter_complex_concat = []
filter_complex_scale = []
curr_video = 0
# -filter_complex
# "[0:v]scale=1024:576:force_original_aspect_ratio=1[v0];
# [1:v]scale=1024:576:force_original_aspect_ratio=1[v1];
# [v0][0:a][v1][1:a]concat=n=2:v=1:a=1[v][a]"
# For every input construct their filter complex to be added later
# Force scaling of videos first
for video_file in video_files:
video_file_path = Path(video_file)
# Attempt to find a cut point for this video if there are cut points defined
#-ss 00:33 -t 30
if not cuts is None and video_file_path.name in cuts:
video_cut_info = cuts[video_file_path.name]
if 'ss' in video_cut_info:
prog_args.append("-ss")
prog_args.append(str(video_cut_info['ss']))
if 't' in video_cut_info:
prog_args.append("-t")
prog_args.append(str(video_cut_info['t']))
prog_args.append("-i")
prog_args.append(str(video_file_path)) # Don't surrount with quotes ""
# Add the scaling instructions for the input video and give it a new output
# Force downscaling of aspect ratio and size to the minimal available
# the value of =1 is the same as ‘decrease’ => The output video dimensions will automatically be decreased if needed.
if args_burnsubs:
# More info on the subtitles filter http://ffmpeg.org/ffmpeg-filters.html#subtitles
filter_complex_scale.append("[{0}:v]scale={1}:force_original_aspect_ratio=1[vv{0}];[vv{0}]subtitles='{2}':force_style='FontName=Arial,Fontsize=24'[v{0}];".format(curr_video, args_videomaxsize, str(video_file_path).replace('\\', '/').replace(':', '\:'))) # Note the path must have forward slashes AND we must escape the colon!!
else:
filter_complex_scale.append("[{0}:v]scale={1}:force_original_aspect_ratio=1[v{0}];".format(curr_video, args_videomaxsize))
# Add concat filter with the video output from the scaling and audio index from the original video
filter_complex_concat.append("[v{0}]".format(curr_video))
if audio_is_enabled:
filter_complex_concat.append("[{0}:a]".format(curr_video))
curr_video += 1
# Add the final part of the concat filter
audio_track = ':a=1' if audio_is_enabled else ''
filter_complex_concat.append("concat=n={0}:v=1{1}".format(video_count, audio_track))
filter_complex_concat.append("[v]")
if audio_is_enabled:
filter_complex_concat.append("[a]")
# Join and add the filter complex to the args
# First the scaling then the concats
prog_args.append("-filter_complex")
prog_args.append("".join(filter_complex_scale) + "".join(filter_complex_concat)) # Don't surrount with quotes ""
# The mapping for the video and audio
prog_args.append("-map")
prog_args.append("[v]")
if audio_is_enabled:
prog_args.append("-map")
prog_args.append("[a]")
# Don't show copyright header
prog_args.append("-hide_banner")
# Don't show excess logging (only things that cause the exe to terminate)
prog_args.append("-loglevel")
prog_args.append("verbose")
# Force showing progress indicator text
prog_args.append("-stats")
# Overwrite any prompts with YES
prog_args.append("-y")
# Finally the output file
prog_args.append(str(path_out_file)) # Don't surrount with quotes ""
# Disable colour output from FFMPEG before we start
os.environ['AV_LOG_FORCE_NOCOLOR'] = "1"
# Run ffmpeg and wait for the output file to be created before returning
return _runSubProcess(prog_args, path_to_wait_on=path_out_file)
#
# Calls mp4box to create the concatinated video file and includes the chapter file as well
def addChaptersToVideoFile(mp4box_path, path_video_file, path_chapters_file):
# Check to see if the video file exists before doing anything
if not path_video_file.exists():
raise ValueError("Video file {0} could not be found. No chapters were added.".format(path_video_file))
# Construct the args to mp4box
prog_args = [mp4box_path]
# Overwrite the default temporary folder to somewhere we
# know that the current user has write privileges
prog_args.append("-tmp")
prog_args.append("{0}".format(os.environ['TMP']))
# Add the chapter file
prog_args.append("-add")
prog_args.append(str(path_chapters_file)+":chap")
# Add the output file at the very end, we will add the
# chapter marks in-place
prog_args.append(str(path_video_file))
# Run the command
return _runSubProcess(prog_args)
#
# Splits an existing video file into requested chunks
def splitVideoFile(mp4box_path, path_video_file, max_out_size_kb):
# Can't split something that doesn't exist
if not | path_video_file.exists():
raise ValueError("Video file {0} could not be found. Nothing was split.".format(path_video_file))
# Construct the args to mp4box
prog_args = [mp4box_path]
# Specify the maximum split size
prog_args.append("-splits")
prog_args.append(str(max_out_size_kb))
# Overwrite the default temporary folder to somewhere we
# know that the current user has write privileges
prog_args.append("-tmp")
prog_args.append("{0}".format(os.environ['TMP']))
# Add the input file we want to split
prog_args.append(str(path_video_file))
# Specify the same file again as an out parameter to use the same directory
prog_args.append("-out") | identifier_body | |
combine.py | CombinedVideoFile(video_files, chapters, cumulative_dur, cumulative_size, mp4exec, ffmpegexec, path_out_file, path_chapters_file, args.overwrite, cuts, args.videosize, args.burnsubs, max_out_size_kb, args.noaudio )
print(Colors.success("Script completed successfully, bye!"))
finally:
deinit() #Deinitialize the colorama library
# Reads and parses cut information for the input files
def parseCutPointInformation(path_to_cuts_file):
cuts = {}
with open(str(path_to_cuts_file), encoding='utf-8') as csvfile:
row_reader = csv.reader(csvfile)
for row in row_reader:
if( len(row) < 2 ):
continue
filename = row[0].strip()
# Create a new entry for the file
cuts[filename] = {}
starttime = row[1].strip()
cuts[filename]['ss'] = starttime
startpoint = sum(x * int(t) for x, t in zip([1, 60, 3600], reversed(starttime.split(":"))))
if len(row) > 2:
timecode = row[2].strip()
fullduration = sum(x * int(t) for x, t in zip([1, 60, 3600], reversed(timecode.split(":"))))
cuts[filename]['t'] = fullduration - startpoint
if len(cuts) <= 0:
return None
return cuts
#
# Creates a combined video file for a segment
def createCombinedVideoFile(video_files, chapters, cumulative_dur, cumulative_size, mp4exec, ffmpegexec, path_out_file, path_chapters_file, args_overwrite, cuts, args_videomaxsize, args_burnsubs, max_out_size_kb=0, args_noaudio=False ):
print( "Output: {0}".format(Colors.fileout(str(path_out_file))))
# Add the final chapter as the end for this segment
chapters.append({"name": "End", "timecode":formatTimedelta(cumulative_dur)})
# Chapters should be +1 more than files as we have an extra chapter ending at the very end of the file
print("{0} chapters, {1} running time, {2} total size".format( len(chapters), formatTimedelta(cumulative_dur), humanize.naturalsize(cumulative_size, gnu=True)))
# Write the chapters file to out
saveChaptersFile(chapters, path_chapters_file)
# Re-encode and combine the video files first
print(Colors.toolpath("Combining and re-encoding video files (ffmpeg), this will take a while..."))
reencodeAndCombineVideoFiles(ffmpegexec, video_files, path_out_file, args_videomaxsize, cuts, args_burnsubs, args_noaudio)
# Now create the combined file and include the chapter marks
print(Colors.toolpath("Adding chapters to combined video file (mp4box)"))
addChaptersToVideoFile(mp4exec, path_out_file, path_chapters_file)
# Delete the chapters file
os.remove(str(path_chapters_file))
# Read the created file to learn its final filesize
size_out_file_kb = os.path.getsize(str(path_out_file)) / 1024
print( Colors.toolpath("Final size of video file is: {0}".format(humanize.naturalsize(size_out_file_kb * 1024))))
# Now split the file if requested
if max_out_size_kb > 0 and size_out_file_kb > max_out_size_kb :
print( Colors.toolpath("Size limit exceeded, splitting video into files of max size: {0}".format(humanize.naturalsize(max_out_size_kb * 1000))))
splitVideoFile(mp4exec, path_out_file, max_out_size_kb)
#
# Attempts to detect the requested size of the output file based on the input parameters
# the absolute_size is overridden by disk_capacity if both are specified
# Returns KB (kilobytes)
def determineMaximumOutputfileSizeInKb(absolute_size, disk_capacity):
if( disk_capacity and disk_capacity in DISKSIZES ):
dsk_cap = DISKSIZES[disk_capacity]
#print( "Disk Capacity: {0}".format(dsk_cap))
return dsk_cap
elif( absolute_size):
#print( "Absolute size: "+absolute_size)
# First remove all spaces from the size string and convert to uppercase, remove all commas from the string
# now attempt to parse the sizes
abs_size = "".join("".join(absolute_size.split(' ')).split(',')).upper()
regex_size_parse = re.compile(r"^(?P<size>[0-9]*(?:\.[0-9]*)?)\s*(?P<unit>GB|MB|KB|B|TB)?$", re.MULTILINE)
match = regex_size_parse.search( absolute_size )
size = float(match.group("size"))
unit = match.group("unit")
#print( "Absolute value: {0}, unit: {1} ".format(size, unit))
if( not unit or not unit in ABSSIZES ):
unit = "MB" # Default is megabytes if nothing is specified
unit_multiplier = ABSSIZES[unit]
total_size = size * unit_multiplier
#print( "Absolute total: {0}, mult: {1} ".format(total_size, unit_multiplier))
return total_size / 1000 # Return kilobytes but in the metric system sense not the "1024 byte sense"
else:
# If nothing is specified then the default return is to use unbounded
return -1
#
# Executes the mp4box app with the -info switch and
# extracts the track length and file size from the output
def parseMp4boxMediaInfo(file_name, mp4box_path, regex_mp4box_duration):
# Get the size of the file in bytes
statinfo = os.stat(file_name)
file_size = statinfo.st_size #Size in bytes of a plain file
# Run the app and collect the output
proc_cmd = [mp4box_path, "-info", "-std", file_name]
ret = subprocess.run(proc_cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
# Ensure that the return code was ok before continuing
if ret.returncode != 0:
print("Command {0} returned non-zero exit status {1}.".format(proc_cmd, ret.returncode))
print("File {0} will be skipped".format(file_name))
return None
#ret.check_returncode()
# Computed Duration 00:23:06.040 - Indicated Duration 00:23:06.040
match = regex_mp4box_duration.search( ret.stdout )
hrs = int(match.group("hrs"))
min = int(match.group("min"))
sec = int(match.group("sec"))
msec = int(match.group("msec"))
duration = timedelta(days=0, hours=hrs, minutes=min, seconds=sec, milliseconds=msec )
return {'file':file_name, 'size':file_size, 'dur':duration }
#
# Locates the mp4box executable and returns a full path to it
def findMp4Box(path_to_gpac_install=None, working_dir=None):
if( not path_to_gpac_install is None and os.path.isfile(os.path.join(path_to_gpac_install, "mp4box.exe")) ):
return os.path.join(path_to_gpac_install, "mp4box.exe")
# Attempts to search for it under the bin folder
bin_dist = os.path.join(working_dir, "..\\bin\\GPAC\\mp4box.exe")
if( os.path.isfile(bin_dist)):
return str(Path(bin_dist).resolve())
# Attempts to search for it under C:\Program Files\GPAC
if( os.path.isfile("C:\\Program Files\\GPAC\\mp4box.exe")):
return "C:\\Program Files\\GPAC\\mp4box.exe"
# For 32 bit installs
if( os.path.isfile("C:\\Program Files\\GPAC\\mp4box.exe")):
return "C:\\Program Files (x86)\\GPAC\\mp4box.exe"
# Throw an error
raise ValueError('Could not locate GPAC install, please use the --gpac switch to specify the path to the mp4box.exe file on your system.')
#
# Locates the ffmpeg executable and returns a full path to it
def findffmpeg(path_to_ffmpeg_install=None, working_dir=None):
if( not path_to_ffmpeg_install is None and os.path.isfile(os.path.join(path_to_ffmpeg_install, "ffmpeg.exe")) ):
return os.path.join(path_to_ffmpeg_install, "ffmpeg.exe")
# Attempts to search for it under the bin folder
bin_dist = os.path.join(working_dir, "..\\bin\\ff\\ffmpeg.exe")
if( os.path.isfile(bin_dist)):
return str(Path(bin_dist).resolve())
# Throw an error
raise ValueError('Could not locate FFMPEG install, please use the --ffmpeg switch to specify the path to the ffmpeg.exe file on your system.')
#
# Returns an array of files matching the grep string passed in
def | getFileNamesFromGrepMatch | identifier_name | |
window.rs | new(
grid_id: u64,
window_type: WindowType,
anchor_info: Option<AnchorInfo>,
grid_position: (f64, f64),
grid_size: (u64, u64),
draw_command_batcher: Arc<DrawCommandBatcher>,
) -> Window {
let window = Window {
grid_id,
grid: CharacterGrid::new(grid_size),
window_type,
anchor_info,
grid_position,
draw_command_batcher,
};
window.send_updated_position();
window
}
fn send_command(&self, command: WindowDrawCommand) {
self.draw_command_batcher
.queue(DrawCommand::Window {
grid_id: self.grid_id,
command,
})
.ok();
}
fn send_updated_position(&self) {
self.send_command(WindowDrawCommand::Position {
grid_position: self.grid_position,
grid_size: (self.grid.width, self.grid.height),
floating_order: self.anchor_info.clone().map(|anchor| anchor.sort_order),
});
}
pub fn get_cursor_grid_cell(
&self,
window_left: u64,
window_top: u64,
) -> (String, Option<Arc<Style>>, bool) {
let grid_cell = match self.grid.get_cell(window_left, window_top) {
Some((character, style)) => (character.clone(), style.clone()),
_ => (' '.to_string(), None),
};
let double_width = match self.grid.get_cell(window_left + 1, window_top) {
Some((character, _)) => character.is_empty(),
_ => false,
};
(grid_cell.0, grid_cell.1, double_width)
}
pub fn get_width(&self) -> u64 {
self.grid.width
}
pub fn get_height(&self) -> u64 {
self.grid.height
}
pub fn get_grid_position(&self) -> (f64, f64) {
self.grid_position
}
pub fn position(
&mut self,
anchor_info: Option<AnchorInfo>,
grid_size: (u64, u64),
grid_position: (f64, f64),
) {
self.grid.resize(grid_size);
self.anchor_info = anchor_info;
self.grid_position = grid_position;
self.send_updated_position();
self.redraw();
}
pub fn resize(&mut self, new_size: (u64, u64)) {
self.grid.resize(new_size);
self.send_updated_position();
self.redraw();
}
fn modify_grid(
&mut self,
row_index: u64,
column_pos: &mut u64,
cell: GridLineCell,
defined_styles: &HashMap<u64, Arc<Style>>,
previous_style: &mut Option<Arc<Style>>,
) {
// Get the defined style from the style list.
let style = match cell.highlight_id {
Some(0) => None,
Some(style_id) => defined_styles.get(&style_id).cloned(),
None => previous_style.clone(),
};
// Compute text.
let mut text = cell.text;
if let Some(times) = cell.repeat {
text = text.repeat(times as usize);
}
// Insert the contents of the cell into the grid.
if text.is_empty() {
if let Some(cell) = self.grid.get_cell_mut(*column_pos, row_index) {
*cell = (text, style.clone());
}
*column_pos += 1;
} else {
for character in text.graphemes(true) {
if let Some(cell) = self.grid.get_cell_mut(*column_pos, row_index) {
*cell = (character.to_string(), style.clone());
}
*column_pos += 1;
}
}
*previous_style = style;
}
// Build a line fragment for the given row starting from current_start up until the next style
// change or double width character.
fn build_line_fragment(&self, row_index: u64, start: u64) -> (u64, LineFragment) {
let row = self.grid.row(row_index).unwrap();
let (_, style) = &row[start as usize];
let mut text = String::new();
let mut width = 0;
for possible_end_index in start..self.grid.width {
let (character, possible_end_style) = &row[possible_end_index as usize];
// Style doesn't match. Draw what we've got.
if style != possible_end_style {
break;
}
width += 1;
// The previous character is double width, so send this as its own draw command.
if character.is_empty() {
break;
}
// Add the grid cell to the cells to render.
text.push_str(character);
}
let line_fragment = LineFragment {
text,
window_left: start,
window_top: row_index,
width,
style: style.clone(),
};
(start + width, line_fragment)
}
// Redraw line by calling build_line_fragment starting at 0
// until current_start is greater than the grid width and sending the resulting
// fragments as a batch.
fn redraw_line(&self, row: u64) {
let mut current_start = 0;
let mut line_fragments = Vec::new();
while current_start < self.grid.width {
let (next_start, line_fragment) = self.build_line_fragment(row, current_start);
current_start = next_start;
line_fragments.push(line_fragment);
}
self.send_command(WindowDrawCommand::DrawLine(line_fragments));
}
pub fn draw_grid_line(
&mut self,
row: u64,
column_start: u64,
cells: Vec<GridLineCell>,
defined_styles: &HashMap<u64, Arc<Style>>,
) {
let mut previous_style = None;
if row < self.grid.height {
let mut column_pos = column_start;
for cell in cells {
self.modify_grid(
row,
&mut column_pos,
cell,
defined_styles,
&mut previous_style,
);
}
// Due to the limitations of the current rendering strategy, some underlines get
// clipped by the line below. To mitigate that, we redraw the adjacent lines whenever
// an individual line is redrawn. Unfortunately, some clipping still happens.
// TODO: figure out how to solve this
if row < self.grid.height - 1 {
self.redraw_line(row + 1);
}
self.redraw_line(row);
if row > 0 {
self.redraw_line(row - 1);
}
} else {
warn!("Draw command out of bounds");
}
}
pub fn scroll_region(
&mut self,
top: u64,
bottom: u64,
left: u64,
right: u64,
rows: i64,
cols: i64,
) {
let mut top_to_bottom;
let mut bottom_to_top;
let y_iter: &mut dyn Iterator<Item = i64> = if rows > 0 {
top_to_bottom = (top as i64 + rows)..bottom as i64;
&mut top_to_bottom
} else {
bottom_to_top = (top as i64..(bottom as i64 + rows)).rev();
&mut bottom_to_top
};
self.send_command(WindowDrawCommand::Scroll {
top,
bottom,
left,
right,
rows,
cols,
});
// Scrolls must not only translate the rendered texture, but also must move the grid data
// accordingly so that future renders work correctly.
for y in y_iter {
let dest_y = y - rows;
let mut cols_left;
let mut cols_right;
if dest_y >= 0 && dest_y < self.grid.height as i64 {
let x_iter: &mut dyn Iterator<Item = i64> = if cols > 0 {
cols_left = (left as i64 + cols)..right as i64;
&mut cols_left
} else {
cols_right = (left as i64..(right as i64 + cols)).rev();
&mut cols_right
};
for x in x_iter {
let dest_x = x - cols;
let cell_data = self.grid.get_cell(x as u64, y as u64).cloned();
if let Some(cell_data) = cell_data {
if let Some(dest_cell) =
self.grid.get_cell_mut(dest_x as u64, dest_y as u64)
{
*dest_cell = cell_data;
}
}
}
}
}
}
pub fn clear(&mut self) |
pub fn redraw(&self) {
self.send_command(WindowDrawCommand::Clear);
// Draw the lines from the bottom up so that underlines don't get overwritten by the line
// below.
for row in (0..self.grid.height).rev() {
self.redraw_line(row);
}
}
pub fn hide(&self) {
self.send_command(WindowDrawCommand::Hide);
}
pub fn show(&self) {
| {
self.grid.clear();
self.send_command(WindowDrawCommand::Clear);
} | identifier_body |
window.rs | new(
grid_id: u64,
window_type: WindowType,
anchor_info: Option<AnchorInfo>,
grid_position: (f64, f64),
grid_size: (u64, u64),
draw_command_batcher: Arc<DrawCommandBatcher>,
) -> Window {
let window = Window {
grid_id,
grid: CharacterGrid::new(grid_size),
window_type,
anchor_info,
grid_position,
draw_command_batcher,
};
window.send_updated_position();
window
}
fn | (&self, command: WindowDrawCommand) {
self.draw_command_batcher
.queue(DrawCommand::Window {
grid_id: self.grid_id,
command,
})
.ok();
}
fn send_updated_position(&self) {
self.send_command(WindowDrawCommand::Position {
grid_position: self.grid_position,
grid_size: (self.grid.width, self.grid.height),
floating_order: self.anchor_info.clone().map(|anchor| anchor.sort_order),
});
}
pub fn get_cursor_grid_cell(
&self,
window_left: u64,
window_top: u64,
) -> (String, Option<Arc<Style>>, bool) {
let grid_cell = match self.grid.get_cell(window_left, window_top) {
Some((character, style)) => (character.clone(), style.clone()),
_ => (' '.to_string(), None),
};
let double_width = match self.grid.get_cell(window_left + 1, window_top) {
Some((character, _)) => character.is_empty(),
_ => false,
};
(grid_cell.0, grid_cell.1, double_width)
}
pub fn get_width(&self) -> u64 {
self.grid.width
}
pub fn get_height(&self) -> u64 {
self.grid.height
}
pub fn get_grid_position(&self) -> (f64, f64) {
self.grid_position
}
pub fn position(
&mut self,
anchor_info: Option<AnchorInfo>,
grid_size: (u64, u64),
grid_position: (f64, f64),
) {
self.grid.resize(grid_size);
self.anchor_info = anchor_info;
self.grid_position = grid_position;
self.send_updated_position();
self.redraw();
}
pub fn resize(&mut self, new_size: (u64, u64)) {
self.grid.resize(new_size);
self.send_updated_position();
self.redraw();
}
fn modify_grid(
&mut self,
row_index: u64,
column_pos: &mut u64,
cell: GridLineCell,
defined_styles: &HashMap<u64, Arc<Style>>,
previous_style: &mut Option<Arc<Style>>,
) {
// Get the defined style from the style list.
let style = match cell.highlight_id {
Some(0) => None,
Some(style_id) => defined_styles.get(&style_id).cloned(),
None => previous_style.clone(),
};
// Compute text.
let mut text = cell.text;
if let Some(times) = cell.repeat {
text = text.repeat(times as usize);
}
// Insert the contents of the cell into the grid.
if text.is_empty() {
if let Some(cell) = self.grid.get_cell_mut(*column_pos, row_index) {
*cell = (text, style.clone());
}
*column_pos += 1;
} else {
for character in text.graphemes(true) {
if let Some(cell) = self.grid.get_cell_mut(*column_pos, row_index) {
*cell = (character.to_string(), style.clone());
}
*column_pos += 1;
}
}
*previous_style = style;
}
// Build a line fragment for the given row starting from current_start up until the next style
// change or double width character.
fn build_line_fragment(&self, row_index: u64, start: u64) -> (u64, LineFragment) {
let row = self.grid.row(row_index).unwrap();
let (_, style) = &row[start as usize];
let mut text = String::new();
let mut width = 0;
for possible_end_index in start..self.grid.width {
let (character, possible_end_style) = &row[possible_end_index as usize];
// Style doesn't match. Draw what we've got.
if style != possible_end_style {
break;
}
width += 1;
// The previous character is double width, so send this as its own draw command.
if character.is_empty() {
break;
}
// Add the grid cell to the cells to render.
text.push_str(character);
}
let line_fragment = LineFragment {
text,
window_left: start,
window_top: row_index,
width,
style: style.clone(),
};
(start + width, line_fragment)
}
// Redraw line by calling build_line_fragment starting at 0
// until current_start is greater than the grid width and sending the resulting
// fragments as a batch.
fn redraw_line(&self, row: u64) {
let mut current_start = 0;
let mut line_fragments = Vec::new();
while current_start < self.grid.width {
let (next_start, line_fragment) = self.build_line_fragment(row, current_start);
current_start = next_start;
line_fragments.push(line_fragment);
}
self.send_command(WindowDrawCommand::DrawLine(line_fragments));
}
pub fn draw_grid_line(
&mut self,
row: u64,
column_start: u64,
cells: Vec<GridLineCell>,
defined_styles: &HashMap<u64, Arc<Style>>,
) {
let mut previous_style = None;
if row < self.grid.height {
let mut column_pos = column_start;
for cell in cells {
self.modify_grid(
row,
&mut column_pos,
cell,
defined_styles,
&mut previous_style,
);
}
// Due to the limitations of the current rendering strategy, some underlines get
// clipped by the line below. To mitigate that, we redraw the adjacent lines whenever
// an individual line is redrawn. Unfortunately, some clipping still happens.
// TODO: figure out how to solve this
if row < self.grid.height - 1 {
self.redraw_line(row + 1);
}
self.redraw_line(row);
if row > 0 {
self.redraw_line(row - 1);
}
} else {
warn!("Draw command out of bounds");
}
}
pub fn scroll_region(
&mut self,
top: u64,
bottom: u64,
left: u64,
right: u64,
rows: i64,
cols: i64,
) {
let mut top_to_bottom;
let mut bottom_to_top;
let y_iter: &mut dyn Iterator<Item = i64> = if rows > 0 {
top_to_bottom = (top as i64 + rows)..bottom as i64;
&mut top_to_bottom
} else {
bottom_to_top = (top as i64..(bottom as i64 + rows)).rev();
&mut bottom_to_top
};
self.send_command(WindowDrawCommand::Scroll {
top,
bottom,
left,
right,
rows,
cols,
});
// Scrolls must not only translate the rendered texture, but also must move the grid data
// accordingly so that future renders work correctly.
for y in y_iter {
let dest_y = y - rows;
let mut cols_left;
let mut cols_right;
if dest_y >= 0 && dest_y < self.grid.height as i64 {
let x_iter: &mut dyn Iterator<Item = i64> = if cols > 0 {
cols_left = (left as i64 + cols)..right as i64;
&mut cols_left
} else {
cols_right = (left as i64..(right as i64 + cols)).rev();
&mut cols_right
};
for x in x_iter {
let dest_x = x - cols;
let cell_data = self.grid.get_cell(x as u64, y as u64).cloned();
if let Some(cell_data) = cell_data {
if let Some(dest_cell) =
self.grid.get_cell_mut(dest_x as u64, dest_y as u64)
{
*dest_cell = cell_data;
}
}
}
}
}
}
pub fn clear(&mut self) {
self.grid.clear();
self.send_command(WindowDrawCommand::Clear);
}
pub fn redraw(&self) {
self.send_command(WindowDrawCommand::Clear);
// Draw the lines from the bottom up so that underlines don't get overwritten by the line
// below.
for row in (0..self.grid.height).rev() {
self.redraw_line(row);
}
}
pub fn hide(&self) {
self.send_command(WindowDrawCommand::Hide);
}
pub fn show(&self) {
| send_command | identifier_name |
window.rs | new(
grid_id: u64,
window_type: WindowType,
anchor_info: Option<AnchorInfo>,
grid_position: (f64, f64),
grid_size: (u64, u64),
draw_command_batcher: Arc<DrawCommandBatcher>,
) -> Window {
let window = Window {
grid_id,
grid: CharacterGrid::new(grid_size),
window_type,
anchor_info,
grid_position,
draw_command_batcher,
};
window.send_updated_position();
window
}
fn send_command(&self, command: WindowDrawCommand) {
self.draw_command_batcher
.queue(DrawCommand::Window {
grid_id: self.grid_id,
command,
})
.ok();
}
fn send_updated_position(&self) {
self.send_command(WindowDrawCommand::Position {
grid_position: self.grid_position,
grid_size: (self.grid.width, self.grid.height),
floating_order: self.anchor_info.clone().map(|anchor| anchor.sort_order),
});
}
pub fn get_cursor_grid_cell(
&self,
window_left: u64,
window_top: u64,
) -> (String, Option<Arc<Style>>, bool) {
let grid_cell = match self.grid.get_cell(window_left, window_top) {
Some((character, style)) => (character.clone(), style.clone()),
_ => (' '.to_string(), None),
};
let double_width = match self.grid.get_cell(window_left + 1, window_top) {
Some((character, _)) => character.is_empty(),
_ => false,
};
(grid_cell.0, grid_cell.1, double_width)
}
pub fn get_width(&self) -> u64 {
self.grid.width
}
pub fn get_height(&self) -> u64 {
self.grid.height
}
pub fn get_grid_position(&self) -> (f64, f64) {
self.grid_position
}
pub fn position(
&mut self,
anchor_info: Option<AnchorInfo>,
grid_size: (u64, u64),
grid_position: (f64, f64),
) {
self.grid.resize(grid_size);
self.anchor_info = anchor_info;
self.grid_position = grid_position;
self.send_updated_position();
self.redraw();
}
pub fn resize(&mut self, new_size: (u64, u64)) {
self.grid.resize(new_size);
self.send_updated_position();
self.redraw();
}
fn modify_grid(
&mut self,
row_index: u64,
column_pos: &mut u64,
cell: GridLineCell,
defined_styles: &HashMap<u64, Arc<Style>>,
previous_style: &mut Option<Arc<Style>>,
) {
// Get the defined style from the style list.
let style = match cell.highlight_id {
Some(0) => None,
Some(style_id) => defined_styles.get(&style_id).cloned(),
None => previous_style.clone(),
};
// Compute text.
let mut text = cell.text;
if let Some(times) = cell.repeat {
text = text.repeat(times as usize);
}
// Insert the contents of the cell into the grid.
if text.is_empty() {
if let Some(cell) = self.grid.get_cell_mut(*column_pos, row_index) {
*cell = (text, style.clone());
}
*column_pos += 1;
} else {
for character in text.graphemes(true) {
if let Some(cell) = self.grid.get_cell_mut(*column_pos, row_index) {
*cell = (character.to_string(), style.clone());
}
*column_pos += 1;
}
}
*previous_style = style;
}
// Build a line fragment for the given row starting from current_start up until the next style
// change or double width character.
fn build_line_fragment(&self, row_index: u64, start: u64) -> (u64, LineFragment) {
let row = self.grid.row(row_index).unwrap();
let (_, style) = &row[start as usize];
let mut text = String::new();
let mut width = 0;
for possible_end_index in start..self.grid.width {
let (character, possible_end_style) = &row[possible_end_index as usize];
// Style doesn't match. Draw what we've got.
if style != possible_end_style {
break;
}
width += 1;
// The previous character is double width, so send this as its own draw command.
if character.is_empty() {
break;
}
// Add the grid cell to the cells to render.
text.push_str(character);
}
let line_fragment = LineFragment {
text,
window_left: start,
window_top: row_index,
width,
style: style.clone(),
};
(start + width, line_fragment)
}
// Redraw line by calling build_line_fragment starting at 0
// until current_start is greater than the grid width and sending the resulting
// fragments as a batch.
fn redraw_line(&self, row: u64) {
let mut current_start = 0;
let mut line_fragments = Vec::new();
while current_start < self.grid.width {
let (next_start, line_fragment) = self.build_line_fragment(row, current_start);
current_start = next_start;
line_fragments.push(line_fragment);
}
self.send_command(WindowDrawCommand::DrawLine(line_fragments));
}
pub fn draw_grid_line(
&mut self,
row: u64,
column_start: u64,
cells: Vec<GridLineCell>,
defined_styles: &HashMap<u64, Arc<Style>>,
) {
let mut previous_style = None;
if row < self.grid.height {
let mut column_pos = column_start;
for cell in cells {
self.modify_grid(
row,
&mut column_pos,
cell,
defined_styles,
&mut previous_style,
);
}
// Due to the limitations of the current rendering strategy, some underlines get
// clipped by the line below. To mitigate that, we redraw the adjacent lines whenever
// an individual line is redrawn. Unfortunately, some clipping still happens.
// TODO: figure out how to solve this
if row < self.grid.height - 1 |
self.redraw_line(row);
if row > 0 {
self.redraw_line(row - 1);
}
} else {
warn!("Draw command out of bounds");
}
}
pub fn scroll_region(
&mut self,
top: u64,
bottom: u64,
left: u64,
right: u64,
rows: i64,
cols: i64,
) {
let mut top_to_bottom;
let mut bottom_to_top;
let y_iter: &mut dyn Iterator<Item = i64> = if rows > 0 {
top_to_bottom = (top as i64 + rows)..bottom as i64;
&mut top_to_bottom
} else {
bottom_to_top = (top as i64..(bottom as i64 + rows)).rev();
&mut bottom_to_top
};
self.send_command(WindowDrawCommand::Scroll {
top,
bottom,
left,
right,
rows,
cols,
});
// Scrolls must not only translate the rendered texture, but also must move the grid data
// accordingly so that future renders work correctly.
for y in y_iter {
let dest_y = y - rows;
let mut cols_left;
let mut cols_right;
if dest_y >= 0 && dest_y < self.grid.height as i64 {
let x_iter: &mut dyn Iterator<Item = i64> = if cols > 0 {
cols_left = (left as i64 + cols)..right as i64;
&mut cols_left
} else {
cols_right = (left as i64..(right as i64 + cols)).rev();
&mut cols_right
};
for x in x_iter {
let dest_x = x - cols;
let cell_data = self.grid.get_cell(x as u64, y as u64).cloned();
if let Some(cell_data) = cell_data {
if let Some(dest_cell) =
self.grid.get_cell_mut(dest_x as u64, dest_y as u64)
{
*dest_cell = cell_data;
}
}
}
}
}
}
pub fn clear(&mut self) {
self.grid.clear();
self.send_command(WindowDrawCommand::Clear);
}
pub fn redraw(&self) {
self.send_command(WindowDrawCommand::Clear);
// Draw the lines from the bottom up so that underlines don't get overwritten by the line
// below.
for row in (0..self.grid.height).rev() {
self.redraw_line(row);
}
}
pub fn hide(&self) {
self.send_command(WindowDrawCommand::Hide);
}
pub fn show(&self) {
| {
self.redraw_line(row + 1);
} | conditional_block |
window.rs | fn new(
grid_id: u64,
window_type: WindowType,
anchor_info: Option<AnchorInfo>,
grid_position: (f64, f64),
grid_size: (u64, u64),
draw_command_batcher: Arc<DrawCommandBatcher>,
) -> Window {
let window = Window {
grid_id,
grid: CharacterGrid::new(grid_size),
window_type,
anchor_info,
grid_position,
draw_command_batcher,
};
window.send_updated_position();
window
}
fn send_command(&self, command: WindowDrawCommand) {
self.draw_command_batcher
.queue(DrawCommand::Window {
grid_id: self.grid_id,
command,
})
.ok();
}
fn send_updated_position(&self) {
self.send_command(WindowDrawCommand::Position {
grid_position: self.grid_position,
grid_size: (self.grid.width, self.grid.height),
floating_order: self.anchor_info.clone().map(|anchor| anchor.sort_order),
});
}
pub fn get_cursor_grid_cell(
&self,
window_left: u64,
window_top: u64,
) -> (String, Option<Arc<Style>>, bool) {
let grid_cell = match self.grid.get_cell(window_left, window_top) {
Some((character, style)) => (character.clone(), style.clone()),
_ => (' '.to_string(), None),
};
let double_width = match self.grid.get_cell(window_left + 1, window_top) {
Some((character, _)) => character.is_empty(),
_ => false,
};
(grid_cell.0, grid_cell.1, double_width)
}
pub fn get_width(&self) -> u64 {
self.grid.width
}
pub fn get_height(&self) -> u64 {
self.grid.height
}
pub fn get_grid_position(&self) -> (f64, f64) {
self.grid_position
}
pub fn position(
&mut self,
anchor_info: Option<AnchorInfo>,
grid_size: (u64, u64),
grid_position: (f64, f64),
) {
self.grid.resize(grid_size);
self.anchor_info = anchor_info;
self.grid_position = grid_position;
self.send_updated_position();
self.redraw();
}
pub fn resize(&mut self, new_size: (u64, u64)) {
self.grid.resize(new_size);
self.send_updated_position();
self.redraw();
}
fn modify_grid(
&mut self,
row_index: u64,
column_pos: &mut u64,
cell: GridLineCell,
defined_styles: &HashMap<u64, Arc<Style>>,
previous_style: &mut Option<Arc<Style>>,
) {
// Get the defined style from the style list.
let style = match cell.highlight_id {
Some(0) => None,
Some(style_id) => defined_styles.get(&style_id).cloned(),
None => previous_style.clone(),
};
// Compute text.
let mut text = cell.text;
if let Some(times) = cell.repeat {
text = text.repeat(times as usize);
}
// Insert the contents of the cell into the grid.
if text.is_empty() {
if let Some(cell) = self.grid.get_cell_mut(*column_pos, row_index) {
*cell = (text, style.clone());
}
*column_pos += 1;
} else {
for character in text.graphemes(true) {
if let Some(cell) = self.grid.get_cell_mut(*column_pos, row_index) {
*cell = (character.to_string(), style.clone());
}
*column_pos += 1;
}
}
*previous_style = style;
}
// Build a line fragment for the given row starting from current_start up until the next style
// change or double width character.
fn build_line_fragment(&self, row_index: u64, start: u64) -> (u64, LineFragment) {
let row = self.grid.row(row_index).unwrap();
let (_, style) = &row[start as usize];
let mut text = String::new();
let mut width = 0;
for possible_end_index in start..self.grid.width {
let (character, possible_end_style) = &row[possible_end_index as usize];
// Style doesn't match. Draw what we've got.
if style != possible_end_style {
break;
}
width += 1;
// The previous character is double width, so send this as its own draw command.
if character.is_empty() {
break; | }
let line_fragment = LineFragment {
text,
window_left: start,
window_top: row_index,
width,
style: style.clone(),
};
(start + width, line_fragment)
}
// Redraw line by calling build_line_fragment starting at 0
// until current_start is greater than the grid width and sending the resulting
// fragments as a batch.
fn redraw_line(&self, row: u64) {
let mut current_start = 0;
let mut line_fragments = Vec::new();
while current_start < self.grid.width {
let (next_start, line_fragment) = self.build_line_fragment(row, current_start);
current_start = next_start;
line_fragments.push(line_fragment);
}
self.send_command(WindowDrawCommand::DrawLine(line_fragments));
}
pub fn draw_grid_line(
&mut self,
row: u64,
column_start: u64,
cells: Vec<GridLineCell>,
defined_styles: &HashMap<u64, Arc<Style>>,
) {
let mut previous_style = None;
if row < self.grid.height {
let mut column_pos = column_start;
for cell in cells {
self.modify_grid(
row,
&mut column_pos,
cell,
defined_styles,
&mut previous_style,
);
}
// Due to the limitations of the current rendering strategy, some underlines get
// clipped by the line below. To mitigate that, we redraw the adjacent lines whenever
// an individual line is redrawn. Unfortunately, some clipping still happens.
// TODO: figure out how to solve this
if row < self.grid.height - 1 {
self.redraw_line(row + 1);
}
self.redraw_line(row);
if row > 0 {
self.redraw_line(row - 1);
}
} else {
warn!("Draw command out of bounds");
}
}
pub fn scroll_region(
&mut self,
top: u64,
bottom: u64,
left: u64,
right: u64,
rows: i64,
cols: i64,
) {
let mut top_to_bottom;
let mut bottom_to_top;
let y_iter: &mut dyn Iterator<Item = i64> = if rows > 0 {
top_to_bottom = (top as i64 + rows)..bottom as i64;
&mut top_to_bottom
} else {
bottom_to_top = (top as i64..(bottom as i64 + rows)).rev();
&mut bottom_to_top
};
self.send_command(WindowDrawCommand::Scroll {
top,
bottom,
left,
right,
rows,
cols,
});
// Scrolls must not only translate the rendered texture, but also must move the grid data
// accordingly so that future renders work correctly.
for y in y_iter {
let dest_y = y - rows;
let mut cols_left;
let mut cols_right;
if dest_y >= 0 && dest_y < self.grid.height as i64 {
let x_iter: &mut dyn Iterator<Item = i64> = if cols > 0 {
cols_left = (left as i64 + cols)..right as i64;
&mut cols_left
} else {
cols_right = (left as i64..(right as i64 + cols)).rev();
&mut cols_right
};
for x in x_iter {
let dest_x = x - cols;
let cell_data = self.grid.get_cell(x as u64, y as u64).cloned();
if let Some(cell_data) = cell_data {
if let Some(dest_cell) =
self.grid.get_cell_mut(dest_x as u64, dest_y as u64)
{
*dest_cell = cell_data;
}
}
}
}
}
}
pub fn clear(&mut self) {
self.grid.clear();
self.send_command(WindowDrawCommand::Clear);
}
pub fn redraw(&self) {
self.send_command(WindowDrawCommand::Clear);
// Draw the lines from the bottom up so that underlines don't get overwritten by the line
// below.
for row in (0..self.grid.height).rev() {
self.redraw_line(row);
}
}
pub fn hide(&self) {
self.send_command(WindowDrawCommand::Hide);
}
pub fn show(&self) {
| }
// Add the grid cell to the cells to render.
text.push_str(character); | random_line_split |
Projeto.py | icao, s tem de ser str
# de tamanho 1, e verificacao_letras_mgc tem de ser verdadeiro
if not e_pos (p) or not isinstance (s, str) or len(s) != 1 or not verificacao_letras_mgc (letras, mgc):
raise ValueError ('gera_chave_espiral: argumentos errados')
# Transforma em lista para poder ser manipulado
letras = list(letras)
r = []
# Verifica cada caracter dentro de mgc
for i in range (len( mgc)):
# Testa se o caracter nao esta ja em r e se esta em letras
if not mgc[i] in r and mgc[i] in letras:
# Se sim, junta-o a r
r += [mgc[i]]
# Remove de letras esse caracter de mgc
letras.remove (mgc[i])
# soma o que restou nas letras (os caracteres nao presentes em mgc)
r += letras
# Ordena em espiral segundo a posicao
r = ordenar (r, p)
if s == 'c':
# se for contra os ponteiros a matriz tem de ser transposta
r = transpor (r, p)
# corta
r = [r[0:5],r[5:10],r[10:15],r[15:20],r[20:25]]
return r
# AUXILIAR (gera_chave_linhas)
# ordenar: lista + posicao --> lista
# ordenar (l,p) recebe uma lista, e uma posicao inicial a partir da qual ordena a lista em espiral
# no sentido dos ponteiros do relogio
def ordenar (l, p):
# ordem e o dicionario com as posicoes em espiral
dic_posicoes = {(0,0) : dic00, (0,4) : dic04, (4,0): dic40, (4,4): dic44}
ordem = dic_posicoes [p]
resp = []
for i in range (0, 25):
# Coloca em resp a respetiva letra de l agora de forma ondenada
resp += [ l [ordem[i]] ]
return resp
# Dicionarios de posicoes (Def ordenar)
dic00 = {0:0, 1:1, 2:2, 3:3, 4:4, 5:15, 6:16, 7:17, 8:18, 9:5, 10:14, 11:23, 12:24, 13:19, 14:6, 15:13, 16:22, 17:21, 18:20, 19:7, 20:12, 21:11, 22:10, 23:9, 24:8}
dic04 = {0:12, 1:13, 2:14, 3:15, 4:0, 5:11, 6:22, 7:23, 8:16, 9:1, 10:10, 11:21, 12:24, 13:17, 14:2, 15:9 , 16:20, 17:19, 18:18, 19:3, 20:8, 21:7, 22:6, 23:5, 24:4}
dic44 = {0:8, 1:9 , 2:10, 3:11, 4:12, 5:7, 6:20, 7:21, 8:22, 9:13, 10:6, 11:19, 12:24, 13:23, 14:14, 15:5, 16:18, 17:17, 18:16, 19:15, 20:4, 21:3, 22:2, 23:1, 24:0}
dic40 = {0:4, 1:5, 2:6, 3:7, 4:8, 5:3 , 6:18, 7:19, 8:20, 9:9 , 10:2 , 11:17, 12:24, 13:21, 14:10, 15:1 , 16:16, 17:23, 18:22, 19:11, 20:0 , 21:15, 22:14, 23:13,24:12}
# Funcao auxiliar (gera_chave_linhas)
# transpor: lista + posicao --> lista
# transpor (l,p) recebe uma lista a transpor, e uma posicao inicial para saber como transpor.
# Se for 0,0 or 4,4 a transposicao e uma reflexao em relacao a diagonal principal
# Se for 0,4 ou 4,0 esta e uma reflexao em relacao a diagonal secundaria
def transpor (l, p):
d = []
# Matriz de replexao em relacao a diagonal principal
dic = transposicao_impar
# Se for 4,4 ou 0,0 reflexao em relacao a diagonal pricipal
if linha_pos (p) == coluna_pos (p):
dic = transposicao_par
# Caso contrario e em relacao a diagonal secundaria
else:
dic = transposicao_impar
for i in range (25):
# Ordena os elementos de l segundo o dicionario escolhido
d += [ l [dic[i]] ]
return d
# Dicionario de transposicao (def transpor)
transposicao_par = {0:0, 1:5, 2:10, 3:15, 4:20, 5:1, 6:6, 7:11, 8:16, 9:21, 10:2, 11:7, 12:12, 13:17, 14:22, 15:3, 16:8, 17:13, 18:18, 19:23, 20:4, 21:9, 22:14, 23:19, 24:24}
transposicao_impar = {0:24, 1:19, 2:14, 3:9, 4:4, 5:23, 6:18, 7:13, 8:8, 9:3, 10:22, 11:17, 12:12, 13:7, 14:2, 15:21, 16:16, 17:11, 18:6, 19:1, 20:20, 21:15, 22:10, 23:5, 24:0}
# SELETOR
# ref_chave: chave x posicao --> letra
# ref_chave(c; p) recebe como argumentos a chave c e a posicao p e devolve a
# letra que esta em c na posicao p
def ref_chave (c, pos):
return c[linha_pos (pos)] [coluna_pos(pos)]
# MODIFICADOR
# muda_chave: chave x posicao x letra --> chave
# muda_chave(c; p; l) recebe como argumentos a chave c, a posicao p e a letra l
# e devolve a chave c com a letra l na posicao p
def muda_chave (c,p,l):
c[ linha_pos (p)][coluna_pos (p)] = l
return c
# RECONHECEDORES
# e_chave: arg --> Boolean
# e_chave(arg): devolve True se o argumento arg for do tipo chave e Falso caso contrario
def | (arg):
''' para ser do tipo chave tem de ser uma lista constituida por 5 listas cada uma com 5 elementos
que sejam letras maiusculas unicas'''
if len (arg) != | e_chave | identifier_name |
Projeto.py |
return c
# RECONHECEDORES
# e_chave: arg --> Boolean
# e_chave(arg): devolve True se o argumento arg for do tipo chave e Falso caso contrario
def e_chave (arg):
''' para ser do tipo chave tem de ser uma lista constituida por 5 listas cada uma com 5 elementos
que sejam letras maiusculas unicas'''
if len (arg) != 5 or not isinstance (arg, list):
return False
for a in arg:
# Testa tipo, tamanho, e se nao ha letras repetidas em cada lista dentro da lista
if not isinstance (arg, list) or len(a) != 5 or len (set (a)) != len (a):
return False
for b in a:
# Testa de algum elemento e uma letra minuscula
if not ( 64 < ord(b) < 91):
return False
else:
return True
# TRANSFORMADORES
# string_chave: chave --> str
# string_chave(c) devolve uma cadeia de caracteres que uma vez impressa apresenta
# as letras de c dispostas numa tabela 5 x 5
def string_chave (chave):
c = ''
for linha in chave:
# Coloca espacos entra as letras
for celula in linha:
c = c + celula + ' '
# Coloca no fim de cada linha paragrafo
c += '\n'
return c
# **********************************************************
# FUNCOES A DESEMVOLVER
# **********************************************************
# diagramas: str --> str
# digramas (mens) recebe como argumento uma cadeia de caracteres
# correspondente a uma mensagem, mens, e devolve a cadeia de caracteres
# correspondente aos digramas transformados de mens sem espacos
def digramas (mens):
mensg = ''
for i in range (len(mens)-1, -1, -1):
# Retira espacos
if mens [i] != ' ':
mensg = mens[i] + mensg
for i in range (0, len(mensg)-1, 2):
# Coloca X se existirem digitos iguais
if mensg[i] == mensg [i+1]:
mensg = mensg[:i+1] + 'X' + mensg[i+1:]
# Testa para ver se ha numeros par de caracteres
if len (mensg) % 2 != 0:
# Se nao houver acrescenta X no fim
mensg += 'X'
return mensg
# figura: digrm + chave --> fig + pos1 + pos2
# figura(digrm, chave) recebe dois argumentos, digrm, uma cadeia de
# caracteres de comprimento 2, e chave, e devolve um tuplo de 3 elementos
# da forma (fig, pos1, pos2) em que:
# - fig e a figura determinada pelas letras de digrm, 'l', 'c' ou 'r' (linha, coluna ou
# rectangulo).
# - pos1 e pos2 sao as posicoes ocupadas na chave pela primeira e segunda letras de
# digrm, respectivamente.
def figura (digrm, chave):
t = ()
# Ciclo para determinar posicao de uma letra na chave
for a in digrm:
# cada lista dentro da lista
for i in range (0,5):
for j in range (0,5):
# Verifica se o digito e igual ao digito da posicao i,j da chave
if a == ref_chave (chave, faz_pos (i,j)):
# Encontra posicao do digito e acumula
t += (faz_pos(i,j),)
# Testa se estao na mesma linha
if linha_pos(t[0]) == linha_pos(t[1]):
return ('l',) + t
# Testa de estao na mesma coluna
if coluna_pos (t[0]) == coluna_pos (t[1]):
return ('c',) + t
# Se estao em retangulo
else:
return ('r',) + t
# codifica_l: posicao + posicao + {-1,1} --> posicao + posicao
# codifica_l (pos1, pos2, inc) recebe tres argumentos, pos1, pos2,
# consistindo nas posicoes das letras de um digrama na mesma linha de uma
# chave, e o inteiro inc, que podera ser 1 (encriptar) ou -1 (desencriptar).
# Devolve um tuplo de 2 posicoes (pos1_cod, pos2_cod) que correspondem as
# posicoes das letras do digrama encriptado/desencriptado.
def codifica_l (pos1, pos2, inc):
c = ()
# Acede a cada posicao dada
for posicao in (pos1,pos2):
# Testa se a coluna e 1, 2, 3
if coluna_pos (posicao) != 4 and coluna_pos (posicao) != 0 :
# se sim, retorna a mesma posicao com a coluna alterada ( coluna + 1
# se for encriptacao, coluna - 1 se for desencriptacao)
c += ( faz_pos ( linha_pos (posicao) , coluna_pos (posicao) + inc ), )
# Testa se e encriptacao
elif inc == 1:
# se sim e se a posicao tiver 4 na coluna entao volta a ficar com 0
# se esta tiver 0 atualiza a coluna com 1 (0+1)
c += (faz_pos ( linha_pos (posicao) , 0),) if coluna_pos (posicao) == 4 else (faz_pos ( linha_pos (posicao) , 1),)
# Desemcriptacao
else:
# Se a posicao tiver 4 na coluna fica com 3 (4-1)
# Se tiver 0 fica com 4
c += (faz_pos ( linha_pos (posicao) , 3),) if coluna_pos (posicao) == 4 else (faz_pos ( linha_pos (posicao) , 4),)
return c
# codifica_l: posicao + posicao + {-1,1} --> posicao + posicao
# codifica_l (pos1, pos2, inc) recebe tres argumentos, pos1, pos2,
# consistindo nas posicoes das letras de um digrama na mesma coluna de uma
# chave, e o inteiro inc, que podera ser 1 (encriptao) ou -1 (desencriptar).
# Devolve um tuplo de 2 posicoes (pos1_cod, pos2_cod) que correspondem as
# posicoes das letras do digrama encriptado/desencriptado.
def codifica_c (pos1, pos2, inc):
c = ()
# Acede a cada posicao dada
for posicao in (pos1,pos2):
# Testa se a linha e 1, 2, 3
if linha_pos (posicao) != 4 and linha_pos (posicao) != 0 :
# se sim, retorna a mesma posicao com a linha alterada ( linha + 1
# se for encriptacao, linha - 1 se for desencriptacao)
c += ( faz_pos ( linha_pos (posicao) + inc, coluna_pos (posicao)), )
# Testa se e encriptacao
elif inc == 1:
# se sim e se a posicao tiver 4 na linha entao volta a ficar com 0
# se esta tiver 0, atualiza a linha com 1 (0+1)
c += (faz_pos ( 0 , coluna_pos (posicao)),) if linha_pos (posicao) == 4 else (faz_pos ( 1 , coluna_pos (posicao)),)
# Desemcriptacao
else:
# Se a posicao tiver 4 na linha fica com 4-1 = 3
# Se tiver 0 fica volta ao 4
c += (faz_pos ( 3 , coluna_pos (posicao)),) if linha_pos (posicao) == 4 else (faz_pos ( 4, coluna_pos (posicao)),)
return c
| # codifica_r: posicao + posicao --> posicao + posicao
# codifica_r (pos1, pos2) recebe dois argumentos, pos1, pos2, consistindo nas
# posicoes das letras de um digrama numa chave. Estas posicoes encontra-se | random_line_split | |
Projeto.py | Verifica cada caracter dentro de mgc
for i in range (len( mgc)):
# Testa se o caracter nao esta ja em r e se esta em letras
if not mgc[i] in r and mgc[i] in letras:
# Se sim, junta-o a r
r += [mgc[i]]
# Remove de letras esse caracter de mgc
letras.remove (mgc[i])
# soma o que restou nas letras (os caracteres nao presentes em mgc)
r += letras
# Ordena em espiral segundo a posicao
r = ordenar (r, p)
if s == 'c':
# se for contra os ponteiros a matriz tem de ser transposta
r = transpor (r, p)
# corta
r = [r[0:5],r[5:10],r[10:15],r[15:20],r[20:25]]
return r
# AUXILIAR (gera_chave_linhas)
# ordenar: lista + posicao --> lista
# ordenar (l,p) recebe uma lista, e uma posicao inicial a partir da qual ordena a lista em espiral
# no sentido dos ponteiros do relogio
def ordenar (l, p):
# ordem e o dicionario com as posicoes em espiral
dic_posicoes = {(0,0) : dic00, (0,4) : dic04, (4,0): dic40, (4,4): dic44}
ordem = dic_posicoes [p]
resp = []
for i in range (0, 25):
# Coloca em resp a respetiva letra de l agora de forma ondenada
resp += [ l [ordem[i]] ]
return resp
# Dicionarios de posicoes (Def ordenar)
dic00 = {0:0, 1:1, 2:2, 3:3, 4:4, 5:15, 6:16, 7:17, 8:18, 9:5, 10:14, 11:23, 12:24, 13:19, 14:6, 15:13, 16:22, 17:21, 18:20, 19:7, 20:12, 21:11, 22:10, 23:9, 24:8}
dic04 = {0:12, 1:13, 2:14, 3:15, 4:0, 5:11, 6:22, 7:23, 8:16, 9:1, 10:10, 11:21, 12:24, 13:17, 14:2, 15:9 , 16:20, 17:19, 18:18, 19:3, 20:8, 21:7, 22:6, 23:5, 24:4}
dic44 = {0:8, 1:9 , 2:10, 3:11, 4:12, 5:7, 6:20, 7:21, 8:22, 9:13, 10:6, 11:19, 12:24, 13:23, 14:14, 15:5, 16:18, 17:17, 18:16, 19:15, 20:4, 21:3, 22:2, 23:1, 24:0}
dic40 = {0:4, 1:5, 2:6, 3:7, 4:8, 5:3 , 6:18, 7:19, 8:20, 9:9 , 10:2 , 11:17, 12:24, 13:21, 14:10, 15:1 , 16:16, 17:23, 18:22, 19:11, 20:0 , 21:15, 22:14, 23:13,24:12}
# Funcao auxiliar (gera_chave_linhas)
# transpor: lista + posicao --> lista
# transpor (l,p) recebe uma lista a transpor, e uma posicao inicial para saber como transpor.
# Se for 0,0 or 4,4 a transposicao e uma reflexao em relacao a diagonal principal
# Se for 0,4 ou 4,0 esta e uma reflexao em relacao a diagonal secundaria
def transpor (l, p):
d = []
# Matriz de replexao em relacao a diagonal principal
dic = transposicao_impar
# Se for 4,4 ou 0,0 reflexao em relacao a diagonal pricipal
if linha_pos (p) == coluna_pos (p):
dic = transposicao_par
# Caso contrario e em relacao a diagonal secundaria
else:
dic = transposicao_impar
for i in range (25):
# Ordena os elementos de l segundo o dicionario escolhido
d += [ l [dic[i]] ]
return d
# Dicionario de transposicao (def transpor)
transposicao_par = {0:0, 1:5, 2:10, 3:15, 4:20, 5:1, 6:6, 7:11, 8:16, 9:21, 10:2, 11:7, 12:12, 13:17, 14:22, 15:3, 16:8, 17:13, 18:18, 19:23, 20:4, 21:9, 22:14, 23:19, 24:24}
transposicao_impar = {0:24, 1:19, 2:14, 3:9, 4:4, 5:23, 6:18, 7:13, 8:8, 9:3, 10:22, 11:17, 12:12, 13:7, 14:2, 15:21, 16:16, 17:11, 18:6, 19:1, 20:20, 21:15, 22:10, 23:5, 24:0}
# SELETOR
# ref_chave: chave x posicao --> letra
# ref_chave(c; p) recebe como argumentos a chave c e a posicao p e devolve a
# letra que esta em c na posicao p
def ref_chave (c, pos):
return c[linha_pos (pos)] [coluna_pos(pos)]
# MODIFICADOR
# muda_chave: chave x posicao x letra --> chave
# muda_chave(c; p; l) recebe como argumentos a chave c, a posicao p e a letra l
# e devolve a chave c com a letra l na posicao p
def muda_chave (c,p,l):
c[ linha_pos (p)][coluna_pos (p)] = l
return c
# RECONHECEDORES
# e_chave: arg --> Boolean
# e_chave(arg): devolve True se o argumento arg for do tipo chave e Falso caso contrario
def e_chave (arg):
''' para ser do tipo chave tem de ser uma lista constituida por 5 listas cada uma com 5 elementos
que sejam letras maiusculas unicas'''
if len (arg) != 5 or not isinstance (arg, list):
return False
for a in arg:
# Testa tipo, tamanho, e se nao ha letras repetidas em cada lista dentro da lista
if not isinstance (arg, list) or len(a) != 5 or len (set (a)) != len (a):
return False
for b in a:
# Testa de algum elemento e uma letra minuscula
| if not ( 64 < ord(b) < 91):
return False | conditional_block | |
Projeto.py | :
return ('r',) + t
# codifica_l: posicao + posicao + {-1,1} --> posicao + posicao
# codifica_l (pos1, pos2, inc) recebe tres argumentos, pos1, pos2,
# consistindo nas posicoes das letras de um digrama na mesma linha de uma
# chave, e o inteiro inc, que podera ser 1 (encriptar) ou -1 (desencriptar).
# Devolve um tuplo de 2 posicoes (pos1_cod, pos2_cod) que correspondem as
# posicoes das letras do digrama encriptado/desencriptado.
def codifica_l (pos1, pos2, inc):
c = ()
# Acede a cada posicao dada
for posicao in (pos1,pos2):
# Testa se a coluna e 1, 2, 3
if coluna_pos (posicao) != 4 and coluna_pos (posicao) != 0 :
# se sim, retorna a mesma posicao com a coluna alterada ( coluna + 1
# se for encriptacao, coluna - 1 se for desencriptacao)
c += ( faz_pos ( linha_pos (posicao) , coluna_pos (posicao) + inc ), )
# Testa se e encriptacao
elif inc == 1:
# se sim e se a posicao tiver 4 na coluna entao volta a ficar com 0
# se esta tiver 0 atualiza a coluna com 1 (0+1)
c += (faz_pos ( linha_pos (posicao) , 0),) if coluna_pos (posicao) == 4 else (faz_pos ( linha_pos (posicao) , 1),)
# Desemcriptacao
else:
# Se a posicao tiver 4 na coluna fica com 3 (4-1)
# Se tiver 0 fica com 4
c += (faz_pos ( linha_pos (posicao) , 3),) if coluna_pos (posicao) == 4 else (faz_pos ( linha_pos (posicao) , 4),)
return c
# codifica_l: posicao + posicao + {-1,1} --> posicao + posicao
# codifica_l (pos1, pos2, inc) recebe tres argumentos, pos1, pos2,
# consistindo nas posicoes das letras de um digrama na mesma coluna de uma
# chave, e o inteiro inc, que podera ser 1 (encriptao) ou -1 (desencriptar).
# Devolve um tuplo de 2 posicoes (pos1_cod, pos2_cod) que correspondem as
# posicoes das letras do digrama encriptado/desencriptado.
def codifica_c (pos1, pos2, inc):
c = ()
# Acede a cada posicao dada
for posicao in (pos1,pos2):
# Testa se a linha e 1, 2, 3
if linha_pos (posicao) != 4 and linha_pos (posicao) != 0 :
# se sim, retorna a mesma posicao com a linha alterada ( linha + 1
# se for encriptacao, linha - 1 se for desencriptacao)
c += ( faz_pos ( linha_pos (posicao) + inc, coluna_pos (posicao)), )
# Testa se e encriptacao
elif inc == 1:
# se sim e se a posicao tiver 4 na linha entao volta a ficar com 0
# se esta tiver 0, atualiza a linha com 1 (0+1)
c += (faz_pos ( 0 , coluna_pos (posicao)),) if linha_pos (posicao) == 4 else (faz_pos ( 1 , coluna_pos (posicao)),)
# Desemcriptacao
else:
# Se a posicao tiver 4 na linha fica com 4-1 = 3
# Se tiver 0 fica volta ao 4
c += (faz_pos ( 3 , coluna_pos (posicao)),) if linha_pos (posicao) == 4 else (faz_pos ( 4, coluna_pos (posicao)),)
return c
# codifica_r: posicao + posicao --> posicao + posicao
# codifica_r (pos1, pos2) recebe dois argumentos, pos1, pos2, consistindo nas
# posicoes das letras de um digrama numa chave. Estas posicoes encontra-se
# em linhas e colunas diferentes.
# A funcao devolve (pos1_cod, pos2_cod) que correspondem as posicoes das letras
# do digrama encriptado/desencriptado
def codifica_r (pos1, pos2):
# Retorna duas posicoes com as colunas trocadas entre si
return faz_pos(linha_pos(pos1), coluna_pos(pos2),) , faz_pos(linha_pos(pos2), coluna_pos(pos1))
# codifica_digrama: cad + chave + {1,-1} --> cad
# codifica_digrama ( diagrm, c, inc) recebe tres argumentos, digrm, um digrama,
# chave, uma chave, e o inteiro inc, que podera ser 1(encriptacao) ou
# -1 (desencriptacao).
# A funcao devolve o digrama correspondente a encriptacao/desencriptacao de digrm
# usando a chave.
def codifica_digrama ( diagrm, c, inc):
# Funcao figura que devolve as posicoes dos caracteres no diagrama
# e a sua posicao relativa (na mesma linha, coluna, ou em rectangulo)
coordenadas = figura (diagrm, c)
# Verifica o ultimo elemento retornado por figura se e 'l'
if coordenadas [0] == 'l':
# Chama a funcao codifica_l que devolve duas posicoes (encriptadas ou
# desencriptadas) que estejam na mesma linha
diretriz = codifica_l ( coordenadas [1], coordenadas [2], inc)
# Devolve as dois caracteres correspondentes as duas posicoes
return ref_chave( c, faz_pos (linha_pos(diretriz [0]), coluna_pos(diretriz [0]))) + ref_chave ( c, faz_pos (linha_pos(diretriz [1]), coluna_pos(diretriz [1])))
# Se ultimo elemento retornado por figura e 'c'
if coordenadas [0] == 'c':
# Chama a funcao codifica_c que devolve duas posicoes (encriptadas ou
# desencriptadas) que estejam na mesma coluna
diretriz = codifica_c ( coordenadas [1], coordenadas [2], inc)
# Devolve as dois caracteres correspondentes as duas posicoes
return ref_chave ( c, faz_pos (linha_pos(diretriz [0]), coluna_pos(diretriz [0]))) + ref_chave (c, faz_pos (linha_pos(diretriz [1]), coluna_pos(diretriz [1])))
else:
# Chama a funcao codifica_c que devolve duas posicoes (encriptadas ou
# desencriptadas) que nao estejam na mesma linha ou coluna (em rectangulo)
diretriz = codifica_r ( coordenadas [1], coordenadas [2])
# Devolve as dois caracteres correspondentes as duas posicoes
return ref_chave ( c,faz_pos(linha_pos(diretriz [0]), coluna_pos(diretriz [0]))) + ref_chave (c, faz_pos (linha_pos(diretriz [1]), coluna_pos(diretriz [1])))
# codifica: mens + chave + {1,-1} --> mens
# codifica (mens, chave, inc) recebe tres argumentos, mens, uma mensagem,
# chave, uma chave, e o inteiro inc, que podera ser 1(encriptacao) ou -1
# (desencriptacao).
# A funcao devolve a mensagem correspondente a encriptacao/desencriptacao de mens
# usando a chave.
def codifica (mens, chave, inc):
# Chama a funcao diagramas que devolve uma str igual a mens, sem espacos
# e sem caracteres repetidos
| mens = digramas (mens)
r = ''
# Codifica os caracteres dois a dois
for i in range (0, len(mens)-1, 2):
# Chama codifica_digrama que devolve dois caracteres codificados
r += codifica_digrama (mens[i:i+2], chave, inc)
return r | identifier_body | |
NEF_tester.py | ")
plotrange(lambda x: target(valtopair(x)),xmin,xmax,resolution,"target values")
# plotrange(lambda x:Error(layer.getaverage(valtopair(x)),target(valtopair(x)),1),xmin,xmax,resolution,"error")
ervals = [SQError(layer.getaverage(valtopair(x)),target(valtopair(x)),1) for x in [x/float(resolution) for x in range(resolution*xmin,resolution*xmax)]]
avsq = reduce(lambda x,y:x+y**2,ervals)/len(ervals)
avsq = 0
for er in ervals:
avsq += er
avsq = avsq/len(ervals)
rms = sqrt(-avsq)
if(title != ""):
title += " RMS Error: "+str(rms)
else:
title = "RMS Error: "+str(rms)
plt.title(title)
plt.legend(loc=2)
if(savename != None):
plt.savefig(savename)
if(display):
plt.show()
def plottuning(neuron,xvals):
|
def initplot(layer):
x = -2
t = target(x)
for a in range(int(0.5/deltaT)):
tvals.append(a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
x = -1
for a in range(int(0.5/deltaT)):
tvals.append(0.5+a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
x = 1
for a in range(int(0.5/deltaT)):
tvals.append(1.0+a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
x = 2
for a in range(int(0.5/deltaT)):
tvals.append(1.5+a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
plt.plot(tvals,xhatvals)
plt.show()
def randunit(d):
v = 2
while(np.linalg.norm(v)>1):
v = np.array([random()*2-1.0 for x in range(d)])
return v/np.linalg.norm(v)
def randweighting(d):
var = 0.3
# var = 0.0
return np.array([var*(2*random()-1.0)+1.0,-(var*(2*random()-1.0)+1.0)])
#synapses = [NEF.Synapse(inhibitory = (x%2)*2-1,initialQ = 0.0) for x in range(1000)]
Error.grace = 0.0#70000.00
Error.value = 0.0
Error.tau = 0.000001*NEF.ms
layersize = 100
weight_val = 1#(10*NEF.ms)
inhibsynapses = [NEF.Synapse(inhibitory = -1,initialQ = 0*(random()-0.5)-4.0) for x in range(layersize)]
excitsynapses = [NEF.Synapse(inhibitory = 1,initialQ = 0*(random()-0.5)-4.0) for x in range(layersize)]
#neurons = [NEF.NEFneuron(synapse = x) for x in synapses]
neurons = [NEF.NEFneuron(synapses = [excitsynapses[i],inhibsynapses[i]],e = choice([-1,1])*randweighting(2),alpha = (1.0/400.0)*normalvariate(17*NEF.nA,5*NEF.nA),J_bias = normalvariate(10*NEF.nA,5*NEF.nA),tau_ref = normalvariate(1.5*NEF.ms,0.3*NEF.ms),tau_RC = normalvariate(20*NEF.ms,4*NEF.ms),J_th = normalvariate(1*NEF.nA,.2*NEF.nA)) for i in range(layersize)]
neurons = [NEF.NEFneuron(synapses = [excitsynapses[i],inhibsynapses[i]],e = choice([-1,1])*randweighting(2),alpha = (1.0/400.0)*normalvariate(17*NEF.nA,5*NEF.nA),J_bias = (random()*2-1.0)*20*NEF.nA+7*NEF.nA,tau_ref = normalvariate(1.5*NEF.ms,0.3*NEF.ms),tau_RC = normalvariate(20*NEF.ms,4*NEF.ms),J_th = normalvariate(1*NEF.nA,.2*NEF.nA)) for i in range(layersize)]
layer = NEF.NEF_layer(layer = neurons,tau_PSC = 10 * NEF.ms,weight = weight_val)
#fp = open("neflayer_allpoints")
#layer = load(fp)
#fp.close()
deltaT = 0.001#*NEF.ms
feedbackrate = 100
updaterate = 60.0#20.0#0.25
eta = 0.00003#0#0001
regularization = 0.0000001
samplefrac = 25#60
targetx = 10.0
x = 0.4
time = 2.0#
displaytime = 120
total = 0
print 3/deltaT
tvals = []
xhatvals = []
presolve = True
lstsq = True
#xvals = [x*0.01 for x in range(-200,200)]
res = 100.0
numxvals = 1000
#xvals = [(x*1.0/res,y*1.0/res) for x in range(0,int(res)) for y in range(0,int(res))]
xvals = [valtopair(400.0*(2*random()-1.0)) for x in range(numxvals)]
for i in range(100):
plottuning(choice(neurons),xvals)
plt.title("Noisy Tuning Curves")
if(lstsq):
plt.savefig("noisytuning-"+str(numxvals)+"samples-"+str(layersize)+"neurons")
plt.show()
if(presolve):
NEF.LeastSquaresSolve(xvals,target,layer,regularization=1000)
if(lstsq):
weight_histogram(layer,binnum=50)
plt.savefig("weight-histogram-"+str(numxvals)+"samples-"+str(layersize)+"neurons")
plt.show()
plotavs(layer,-400,400,1,savename = "cm-agnostic-decode-"+str(numxvals)+"samples-"+str(layersize)+"neurons",title="Common Mode Agnostic Decode "+str(numxvals)+" pts")
plt.show()
exit()
else:
plotavs(layer,-400,400,1,display=False)
#plotavs(layer,-400,400,1)
#plotavs(layer,-400,400,1)
#exit()
#initplot(layer)
#plt.savefig("dataplot0_slowrate")
#plt.show()
c = 0
pltcount = 0
erav = 0
eravcount = 0
etrack = 0
etrackcounter = 0
etracks = []
avx = 0
lastetrack = 0
esquaretrack = 0
while(1):
c+=1
for a in range(1):
x = choice([-2,-1,1,2])*0.2#random()*2.0-1.0
x = random()*4.0-2.0
x = choice([-2,-1,0,1,2])
x = targetx
x = 1.0
if(c%2):
x = 0.4
x = 400.0*(random()*2.0-1.0)
# x = 50
pair = valtopair(x)
t = target(pair)
# t = 100
display = (c%int(displaytime/time) == 0)
if(c%500000 == 0 ):
print "epoch: ",c
print "iteration: ",a
print "trying x= "+str(x)+" target is: "+str(t)+" current average is: "+str(layer.getaverage(pair))
print "display: ",display
etot = 0
| yvals = [neuron.a(x) for x in xvals]
vallist = zip(map(pairtoval,xvals),yvals)
vallist.sort(key = lambda x:x[0])
xvals = [x[0] for x in vallist]
yvals = [x[1] for x in vallist]
plt.plot(xvals,yvals) | identifier_body |
NEF_tester.py | (p,target,deltaT):
return -(target-p)**2
def sigmoid(er):
return er
# return (2.0/(1.0+exp(-2*er))-1.0)
targetname = "target"
def weight_histogram(layer,binnum=None):
weights = [reduce(lambda x,synapse:x+synapse.inhibitory*synapse.Pval(),neuron.synapses,0) for neuron in layer.layer]
if(binnum == None):
plt.hist(weights,normed = True)
else:
plt.hist(weights,bins=binnum,normed = True)
def valtopair(x):
if(x>0):
c = x+random()*(2000-2*x)
else:
c = -x + random()*(2000+2*x)
# c = 400+400*random()
fp = (c+x)/2.0
fm = (c-x)/2.0
try:
assert(fp>=0 and fm>=0)
except:
print "c: ",c," x: ",x
exit()
return (fp,fm)
def pairtoval(pair):
return pair[0]-pair[1]
def target(x):
global targetname
targetname = "sin"
z = x[0]-x[1]
# return -z*z
return 400*sin(3.141592654/400*z)#400.0*(z/400.0)#sin(3.14159264/400.0*z)
def plotrange(f,xmin,xmax,resolution,alabel = None):
xvals = [x/float(resolution) for x in range(resolution*xmin,resolution*xmax)]
plt.plot(xvals,map(f,xvals),label = alabel)
def plotavs(layer,xmin,xmax,resolution,savename = None,display = True,title = ""):
plt.clf()
# plotrange(lambda x:layer.getaverage(valtopair(x)),xmin,xmax,"decoded values")
xvals = []
cms = []
decvals = []
dec_pairp=[]
dec_pairm=[]
dec_cms = []
for x in range(resolution*xmin,resolution*xmax):
pair = valtopair(x/float(resolution))
xvals.append(x/float(resolution))
dec = layer.getaverage(pair)
decvals.append(dec)
dec_pair = layer.getpair(pair)
dec_pairp.append(-dec_pair[0])
dec_pairm.append(-dec_pair[1])
cms.append((pair[0]+pair[1])/2.0)
plt.plot(xvals,decvals,label = "decoded values")
plt.plot(xvals,cms,label="input common mode")
plt.plot(xvals,dec_pairp,label="output f+")
plt.plot(xvals,dec_pairm,label="output f-")
# plotrange(layer.getCM,xmin,xmax,"common modes")
plotrange(lambda x: target(valtopair(x)),xmin,xmax,resolution,"target values")
# plotrange(lambda x:Error(layer.getaverage(valtopair(x)),target(valtopair(x)),1),xmin,xmax,resolution,"error")
ervals = [SQError(layer.getaverage(valtopair(x)),target(valtopair(x)),1) for x in [x/float(resolution) for x in range(resolution*xmin,resolution*xmax)]]
avsq = reduce(lambda x,y:x+y**2,ervals)/len(ervals)
avsq = 0
for er in ervals:
avsq += er
avsq = avsq/len(ervals)
rms = sqrt(-avsq)
if(title != ""):
title += " RMS Error: "+str(rms)
else:
title = "RMS Error: "+str(rms)
plt.title(title)
plt.legend(loc=2)
if(savename != None):
plt.savefig(savename)
if(display):
plt.show()
def plottuning(neuron,xvals):
yvals = [neuron.a(x) for x in xvals]
vallist = zip(map(pairtoval,xvals),yvals)
vallist.sort(key = lambda x:x[0])
xvals = [x[0] for x in vallist]
yvals = [x[1] for x in vallist]
plt.plot(xvals,yvals)
def initplot(layer):
x = -2
t = target(x)
for a in range(int(0.5/deltaT)):
tvals.append(a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
x = -1
for a in range(int(0.5/deltaT)):
tvals.append(0.5+a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
x = 1
for a in range(int(0.5/deltaT)):
tvals.append(1.0+a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
x = 2
for a in range(int(0.5/deltaT)):
tvals.append(1.5+a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
plt.plot(tvals,xhatvals)
plt.show()
def randunit(d):
v = 2
while(np.linalg.norm(v)>1):
v = np.array([random()*2-1.0 for x in range(d)])
return v/np.linalg.norm(v)
def randweighting(d):
var = 0.3
# var = 0.0
return np.array([var*(2*random()-1.0)+1.0,-(var*(2*random()-1.0)+1.0)])
#synapses = [NEF.Synapse(inhibitory = (x%2)*2-1,initialQ = 0.0) for x in range(1000)]
Error.grace = 0.0#70000.00
Error.value = 0.0
Error.tau = 0.000001*NEF.ms
layersize = 100
weight_val = 1#(10*NEF.ms)
inhibsynapses = [NEF.Synapse(inhibitory = -1,initialQ = 0*(random()-0.5)-4.0) for x in range(layersize)]
excitsynapses = [NEF.Synapse(inhibitory = 1,initialQ = 0*(random()-0.5)-4.0) for x in range(layersize)]
#neurons = [NEF.NEFneuron(synapse = x) for x in synapses]
neurons = [NEF.NEFneuron(synapses = [excitsynapses[i],inhibsynapses[i]],e = choice([-1,1])*randweighting(2),alpha = (1.0/400.0)*normalvariate(17*NEF.nA,5*NEF.nA),J_bias = normalvariate(10*NEF.nA,5*NEF.nA),tau_ref = normalvariate(1.5*NEF.ms,0.3*NEF.ms),tau_RC = normalvariate(20*NEF.ms,4*NEF.ms),J_th = normalvariate(1*NEF.nA,.2*NEF.nA)) for i in range(layersize)]
neurons = [NEF.NEFneuron(synapses = [excitsynapses[i],inhibsynapses[i]],e = choice([-1,1])*randweighting(2),alpha = (1.0/400.0)*normalvariate(17*NEF.nA,5*NEF.nA),J_bias = (random()*2-1.0)*20*NEF.nA+7*NEF.nA,tau_ref = normalvariate(1.5*NEF.ms,0.3*NEF.ms),tau_RC = normalvariate(20*NEF.ms,4*NEF.ms),J_th = normalvariate(1*NEF.nA,.2*NEF.nA)) for i in range(layersize)]
layer = NEF.NEF_layer(layer = neurons,tau_PSC = 10 * NEF.ms,weight = weight_val)
#fp = open("neflayer_allpoints")
#layer = load(fp)
#fp.close()
deltaT = 0.001#*NEF.ms
feedbackrate = 100
updaterate = 60.0#20.0#0.25
eta = 0.00003#0#0001
regularization = 0.0000001
samplefrac = 25#60
targetx = 10.0
x = 0.4
time = 2.0#
displaytime = 120
total = 0
print 3/deltaT
tvals = []
xhatvals = []
presolve = True
lstsq = True
# | SQError | identifier_name | |
NEF_tester.py | ")
plotrange(lambda x: target(valtopair(x)),xmin,xmax,resolution,"target values")
# plotrange(lambda x:Error(layer.getaverage(valtopair(x)),target(valtopair(x)),1),xmin,xmax,resolution,"error")
ervals = [SQError(layer.getaverage(valtopair(x)),target(valtopair(x)),1) for x in [x/float(resolution) for x in range(resolution*xmin,resolution*xmax)]]
avsq = reduce(lambda x,y:x+y**2,ervals)/len(ervals)
avsq = 0
for er in ervals:
avsq += er
avsq = avsq/len(ervals)
rms = sqrt(-avsq)
if(title != ""):
title += " RMS Error: "+str(rms)
else:
title = "RMS Error: "+str(rms)
plt.title(title)
plt.legend(loc=2)
if(savename != None):
plt.savefig(savename)
if(display):
plt.show()
def plottuning(neuron,xvals):
yvals = [neuron.a(x) for x in xvals]
vallist = zip(map(pairtoval,xvals),yvals)
vallist.sort(key = lambda x:x[0])
xvals = [x[0] for x in vallist]
yvals = [x[1] for x in vallist]
plt.plot(xvals,yvals)
def initplot(layer):
x = -2
t = target(x)
for a in range(int(0.5/deltaT)):
tvals.append(a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
x = -1
for a in range(int(0.5/deltaT)):
tvals.append(0.5+a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
x = 1
for a in range(int(0.5/deltaT)):
tvals.append(1.0+a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
x = 2
for a in range(int(0.5/deltaT)):
tvals.append(1.5+a*deltaT)
xhatvals.append(layer.Process(x,deltaT))
plt.plot(tvals,xhatvals)
plt.show()
def randunit(d):
v = 2
while(np.linalg.norm(v)>1):
v = np.array([random()*2-1.0 for x in range(d)])
return v/np.linalg.norm(v)
def randweighting(d):
var = 0.3
# var = 0.0
return np.array([var*(2*random()-1.0)+1.0,-(var*(2*random()-1.0)+1.0)])
#synapses = [NEF.Synapse(inhibitory = (x%2)*2-1,initialQ = 0.0) for x in range(1000)]
Error.grace = 0.0#70000.00
Error.value = 0.0
Error.tau = 0.000001*NEF.ms
layersize = 100
weight_val = 1#(10*NEF.ms)
inhibsynapses = [NEF.Synapse(inhibitory = -1,initialQ = 0*(random()-0.5)-4.0) for x in range(layersize)]
excitsynapses = [NEF.Synapse(inhibitory = 1,initialQ = 0*(random()-0.5)-4.0) for x in range(layersize)]
#neurons = [NEF.NEFneuron(synapse = x) for x in synapses]
neurons = [NEF.NEFneuron(synapses = [excitsynapses[i],inhibsynapses[i]],e = choice([-1,1])*randweighting(2),alpha = (1.0/400.0)*normalvariate(17*NEF.nA,5*NEF.nA),J_bias = normalvariate(10*NEF.nA,5*NEF.nA),tau_ref = normalvariate(1.5*NEF.ms,0.3*NEF.ms),tau_RC = normalvariate(20*NEF.ms,4*NEF.ms),J_th = normalvariate(1*NEF.nA,.2*NEF.nA)) for i in range(layersize)]
neurons = [NEF.NEFneuron(synapses = [excitsynapses[i],inhibsynapses[i]],e = choice([-1,1])*randweighting(2),alpha = (1.0/400.0)*normalvariate(17*NEF.nA,5*NEF.nA),J_bias = (random()*2-1.0)*20*NEF.nA+7*NEF.nA,tau_ref = normalvariate(1.5*NEF.ms,0.3*NEF.ms),tau_RC = normalvariate(20*NEF.ms,4*NEF.ms),J_th = normalvariate(1*NEF.nA,.2*NEF.nA)) for i in range(layersize)]
layer = NEF.NEF_layer(layer = neurons,tau_PSC = 10 * NEF.ms,weight = weight_val)
#fp = open("neflayer_allpoints")
#layer = load(fp)
#fp.close()
deltaT = 0.001#*NEF.ms
feedbackrate = 100
updaterate = 60.0#20.0#0.25
eta = 0.00003#0#0001
regularization = 0.0000001
samplefrac = 25#60
targetx = 10.0
x = 0.4
time = 2.0#
displaytime = 120
total = 0
print 3/deltaT
tvals = []
xhatvals = []
presolve = True
lstsq = True
#xvals = [x*0.01 for x in range(-200,200)]
res = 100.0
numxvals = 1000
#xvals = [(x*1.0/res,y*1.0/res) for x in range(0,int(res)) for y in range(0,int(res))]
xvals = [valtopair(400.0*(2*random()-1.0)) for x in range(numxvals)]
for i in range(100):
plottuning(choice(neurons),xvals)
plt.title("Noisy Tuning Curves") | plt.show()
if(presolve):
NEF.LeastSquaresSolve(xvals,target,layer,regularization=1000)
if(lstsq):
weight_histogram(layer,binnum=50)
plt.savefig("weight-histogram-"+str(numxvals)+"samples-"+str(layersize)+"neurons")
plt.show()
plotavs(layer,-400,400,1,savename = "cm-agnostic-decode-"+str(numxvals)+"samples-"+str(layersize)+"neurons",title="Common Mode Agnostic Decode "+str(numxvals)+" pts")
plt.show()
exit()
else:
plotavs(layer,-400,400,1,display=False)
#plotavs(layer,-400,400,1)
#plotavs(layer,-400,400,1)
#exit()
#initplot(layer)
#plt.savefig("dataplot0_slowrate")
#plt.show()
c = 0
pltcount = 0
erav = 0
eravcount = 0
etrack = 0
etrackcounter = 0
etracks = []
avx = 0
lastetrack = 0
esquaretrack = 0
while(1):
c+=1
for a in range(1):
x = choice([-2,-1,1,2])*0.2#random()*2.0-1.0
x = random()*4.0-2.0
x = choice([-2,-1,0,1,2])
x = targetx
x = 1.0
if(c%2):
x = 0.4
x = 400.0*(random()*2.0-1.0)
# x = 50
pair = valtopair(x)
t = target(pair)
# t = 100
display = (c%int(displaytime/time) == 0)
if(c%500000 == 0 ):
print "epoch: ",c
print "iteration: ",a
print "trying x= "+str(x)+" target is: "+str(t)+" current average is: "+str(layer.getaverage(pair))
print "display: ",display
etot = 0
av | if(lstsq):
plt.savefig("noisytuning-"+str(numxvals)+"samples-"+str(layersize)+"neurons") | random_line_split |
NEF_tester.py | plt.title("Noisy Tuning Curves")
if(lstsq):
plt.savefig("noisytuning-"+str(numxvals)+"samples-"+str(layersize)+"neurons")
plt.show()
if(presolve):
NEF.LeastSquaresSolve(xvals,target,layer,regularization=1000)
if(lstsq):
weight_histogram(layer,binnum=50)
plt.savefig("weight-histogram-"+str(numxvals)+"samples-"+str(layersize)+"neurons")
plt.show()
plotavs(layer,-400,400,1,savename = "cm-agnostic-decode-"+str(numxvals)+"samples-"+str(layersize)+"neurons",title="Common Mode Agnostic Decode "+str(numxvals)+" pts")
plt.show()
exit()
else:
plotavs(layer,-400,400,1,display=False)
#plotavs(layer,-400,400,1)
#plotavs(layer,-400,400,1)
#exit()
#initplot(layer)
#plt.savefig("dataplot0_slowrate")
#plt.show()
c = 0
pltcount = 0
erav = 0
eravcount = 0
etrack = 0
etrackcounter = 0
etracks = []
avx = 0
lastetrack = 0
esquaretrack = 0
while(1):
c+=1
for a in range(1):
x = choice([-2,-1,1,2])*0.2#random()*2.0-1.0
x = random()*4.0-2.0
x = choice([-2,-1,0,1,2])
x = targetx
x = 1.0
if(c%2):
x = 0.4
x = 400.0*(random()*2.0-1.0)
# x = 50
pair = valtopair(x)
t = target(pair)
# t = 100
display = (c%int(displaytime/time) == 0)
if(c%500000 == 0 ):
print "epoch: ",c
print "iteration: ",a
print "trying x= "+str(x)+" target is: "+str(t)+" current average is: "+str(layer.getaverage(pair))
print "display: ",display
etot = 0
avxtot = 0
count = 0
tvals = []
xhatvals = []
ervals = []
avvals = []
aver = 0.0
averc = 0
etot_up = 0
count_up = 0
# display = True
layer.xhat = 0
lastx = 0
for q in range(samplefrac):
lastx = 0
xtot = 0
count = 0
for z in range(int(time/(samplefrac*deltaT))):
val = layer.Process(pair,deltaT)
xtot += val/deltaT
lastx += val/deltaT
avxtot += layer.average
er = sigmoid(Error(val,t,deltaT))
layer.RecordErr(er)
aver += er
averc += 1
if(display):
tvals.append(a*1.0+z*deltaT)
xhatvals.append(val)
avvals.append(layer.average)
ervals.append(er*eta)
etot += er
count += 1
etot_up += er
count_up += 1
# if(random() <deltaT*feedbackrate):#c%int(updaterate/time)==0 and z ==0):#random() < deltaT*feedbackrate):
# print "updating!"
# layer.Update(-(etot/count)**2,eta)
# layer.RecUpdate(0,0)#abs(etot_up/count_up),eta)
# etot_up = 0
# count_up = 0
# layer.Update(abs(aver/averc),eta)
# aver = 0
# averc = 0
# print "xtot: ",xtot/count
erav += Error(xtot/count,t,1)
# print "recording error: ",Error(xtot/count,t,1)
# print "value: ",xtot/count
avx += xtot/count
eravcount += 1
reperr= erav/eravcount
etrack += layer.layer[0].synapses[0].etrackval()
lastetrack = layer.layer[0].synapses[0].etrackval()
esquaretrack += lastetrack**2
#
# print "diff: ",abs(erav/eravcount-Error(layer.getaverage(pair),t)*(-2*(1-x/float(t)))
errorD = Error(layer.getaverage(pair),t,1)*(2*(1-layer.getaverage(pair)/float(t)))
etracks.append(layer.layer[0].synapses[0].etrackval())
etrackcounter += 1
etrackval = layer.layer[0].synapses[0].etrackval()
# print "current ratio: ",etrackval/(xtot/count - layer.getaverage(pair))
# print (etrackval/(xtot/count - layer.getaverage(pair)) - 0.01)
# print (etrackval/0.01 - ( xtot/count - layer.getaverage(pair)))
# print (xtot/count - (layer.getaverage(pair)+etrackval/0.01))
# print (Error(xtot/count,t,1) - ( Error(layer.getaverage(pair),t,1)+etrackval/0.01))
# assert(etrackval*erav/eravcount == etrackv
# layer.RecUpdate(Error(xtot/count,t,1),eta)
layer.CorrectedRecUpdate(Error(xtot/count,t,1))
if(c% int(updaterate/time)==0):
# plt.hist(etracks)
# plt.show()
etracks = []
print "updating!\n\n"
print "time elapsed: ",c*time
print "xval: ",x
print "target: ",t
print "count: ",count
print "etrackcount: ",etrackcounter
print "last etrack: ",lastetrack
etrackav = etrack/etrackcounter
etracksqav = esquaretrack/etrackcounter
errorval = Error(layer.getaverage(pair),t,1)
errorD = 1#-errorval*abs(layer.getaverage(pair)-t)/(layer.getaverage(pair)-t)
print "error: ",errorval
delta = avx/etrackcounter - layer.getaverage(pair)
print "error plus delta: ",errorval+errorD*etrackav/0.01
print "error (x plus delta): ",Error(layer.getaverage(pair)+etrackav/0.01,t,1)
avgrad = etrack*errorval+esquaretrack/0.01*errorD
print "etrack: average ",(etrack/etrackcounter)
print "etracksquare average: ",esquaretrack/etrackcounter
print "ratio: ",(etrackav)/(avx/etrackcounter-layer.getaverage(pair))#etrackcounter#layer.layer[0].synapses[0].etrack#etrack/etrackcounter
print "average error: ",reperr#etot/count
print "average x: ",avx/etrackcounter
print "current x: ",layer.xhat/(count*deltaT)
print "aval: ",layer.layer[0].a(pair)
print "predicted average: ",layer.getaverage(pair)#avxtot/count
print "pval: ",layer.layer[0].synapses[0].Pval()
print "est grad: ",avgrad
print "average q: ",reduce(lambda x,y:x+y,[reduce(lambda
x,y:x+y.q,neuron.synapses,0) for neuron in layer.layer],0)/len(layer.layer)
etrack = 0
avx = 0
etrackcounter = 0
esquaretrack = 0
erav = 0
eravcount = 0
layer.CorrectedUpdate(eta,regularization)
# layer.finalUpdate(eta)
if(display):
pltcount += 1
savename = ("figs/savedgraph_frequencies_allpoints_correctedupdates_"+str(Error.grace)+"grace_"+str(presolve)+"presolve_"+str(displaytime)+"displaytime_"+str(time)+"perval_"+str(updaterate)+"updaterate_"+str(samplefrac)+"samplefrac_"+targetname+"_"+str(layersize)+"neurons_feedbackrate"+str(feedbackrate)+"_eta"+str(eta)+"_weight"+str(weight_val)+"_aver_clearerr_"+str(pltcount)).replace(".","p")
plt.clf()
plt.title("xvalue = "+str(x)+" target = "+str(t))
v = "1p0"
if (x==0.4):
| v = "0p4" | conditional_block | |
main.py | SPAM_DATA/trec07p/data'.format("/media/sumeet/147A710C7A70EBBC")
_SPAM_EMAIL_LABELS_PATH = '{}/SPAM_DATA/trec07p/full/index'.format("/media/sumeet/147A710C7A70EBBC")
_CACHED_FEATURE_INDEX_NAME_TEMPLATE = 'feature_matrix_cache/{}-{}-feature_index.json'
_CACHED_FEATURES_FILE_PATH_TEMPLATE = 'feature_matrix_cache/{}-{}-features.txt'
_CACHED_FILENAME_PATH_TEMPLATE = 'feature_matrix_cache/{}-{}-filename_index.txt'
_SPLIT_REGEX = re.compile("\\s+")
_PUNCTUATION_TABLE = str.maketrans('', '', string.punctuation)
_STOPWORDS_SET = set(stopwords.words('english'))
_STEMMER = SnowballStemmer('english')
_PART_1_TRIAL_A_TOKENS_SET = None
_PART_1_TRIAL_B_TOKENS_SET = None
@classmethod
@timing
def _parse_labels(cls) -> Dict[str, int]:
logging.info("Parsing labels")
labels_dict = {}
with open(cls._SPAM_EMAIL_LABELS_PATH, 'r') as file:
for line in file:
parts = re.split(cls._SPLIT_REGEX, line)
if parts[0] == 'spam':
label = 1
elif parts[0] == 'ham':
label = 0
else:
raise ValueError("Invalid label")
file_name = parts[1].split("/")[-1]
labels_dict[file_name] = label
logging.info("{} Labels parsed".format(len(labels_dict)))
return labels_dict
@classmethod
def _text_cleaning_helper(cls, text_to_clean):
cleaned_tokens = []
tokens = word_tokenize(text_to_clean)
for token in tokens:
lowered_token = token.lower()
stripped_token = lowered_token.translate(cls._PUNCTUATION_TABLE)
if stripped_token.isalpha() and stripped_token not in cls._STOPWORDS_SET:
cleaned_tokens.append(cls._STEMMER.stem(stripped_token))
return cleaned_tokens
@classmethod
def _clean_email(cls, raw_email: Email) -> Email:
raw_email.cleaned_subject_tokens = cls._text_cleaning_helper(raw_email.subject)
raw_email.cleaned_body_tokens = cls._text_cleaning_helper(raw_email.body)
return raw_email
@classmethod
def _get_emails(cls, email_files):
for email_file in email_files:
email_file_path = '{}/{}'.format(cls._SPAM_EMAIL_DATA_DIR_PATH, email_file)
with open(email_file_path, 'r', encoding='ISO-8859-1') as email_file_fp:
parsed_raw_email = cls._parse_raw_email(email_file_fp)
parsed_raw_email.file_name = email_file
cleaned_email = cls._clean_email(parsed_raw_email)
yield cleaned_email
@classmethod
def _parse_email_payload_from_html(cls, raw_html) -> str:
bs = BeautifulSoup(raw_html, 'html.parser')
return bs.get_text().strip()
@classmethod
def _parse_raw_email(cls, email_file_fp) -> Email:
def _helper(email_body):
content_type = str(email_body.get_content_type())
content_disposition = str(email_body.get_content_disposition())
if content_type == 'text/plain' and 'attachment' not in content_disposition:
parsed_email.body += str(email_body.get_payload())
elif content_type == 'text/html' and 'attachment' not in content_disposition:
parsed_email.body += cls._parse_email_payload_from_html(str(email_body.get_payload()))
body = email.message_from_file(email_file_fp)
parsed_email = Email()
if body['subject']:
parsed_email.subject = body['subject']
if body.is_multipart():
for part in body.walk():
_helper(part)
else:
_helper(body)
return parsed_email
@classmethod
def _get_email_contents_and_labels(cls, email_files, labels_dict, token_filter):
ix = 1
email_contents = []
labels = []
for cleaned_email in cls._get_emails(email_files):
ix += 1
text = " ".join(filter(token_filter,
cleaned_email.cleaned_subject_tokens + cleaned_email.cleaned_body_tokens))
if text:
email_contents.append(text)
file_name = cleaned_email.file_name
labels.append((labels_dict[file_name], file_name))
if ix % 1000 == 0:
logging.info("Emails Read :{}".format(ix))
return email_contents, labels
@classmethod
def _generate_ngrams_using_ES(cls, corpus, all_labels):
def _mtermvector_query_helper(text_chunks):
return {
"docs": [
{"doc": {"text": text}} for text in text_chunks
]
}
def | (min_df=0.02, max_df=0.95):
min_df_value = int(min_df * len(corpus))
max_df_value = int(max_df * len(corpus))
_valid_ngrams = set()
for ngram, no_of_documents in all_ngrams.items():
if min_df_value < no_of_documents < max_df_value:
_valid_ngrams.add(ngram)
return _valid_ngrams
es_client = EsUtils.get_es_client()
all_ngrams = defaultdict(int)
docs = []
indptr = [0]
indices = []
data = []
vocabulary = {}
labels = []
ix = 0
for email_content_chunks in Utils.split_list_into_sub_lists(corpus, sub_list_size=5000):
response = es_client.mtermvectors(index=Constants.AP_DATA_INDEX_NAME,
body=_mtermvector_query_helper(email_content_chunks))
for response_obj in response['docs']:
ngrams = {}
termvectors = response_obj['term_vectors']
if 'text' in termvectors:
for term, term_info in termvectors['text']['terms'].items():
ngrams[term] = term_info['term_freq']
all_ngrams[term] += 1
docs.append(ngrams)
labels.append(all_labels[ix])
ix += 1
valid_ngrams = _get_valid_ngrams()
for d in docs:
for term, count in d.items():
if term in valid_ngrams:
index = vocabulary.setdefault(term, len(vocabulary))
indices.append(index)
data.append(count)
indptr.append(len(indices))
features = csr_matrix((data, indices, indptr), dtype=int)
np.testing.assert_equal(features.shape[0], len(labels))
return features, labels, list(vocabulary.keys())
@classmethod
@timing
def _generate_features(cls, token_filter, use_cached=True, ngram_range=(1, 1), virgil_replies_yes=False):
feature_file_path = cls._CACHED_FEATURES_FILE_PATH_TEMPLATE.format(token_filter.__name__, ngram_range)
feature_name_index_file_path = cls._CACHED_FEATURE_INDEX_NAME_TEMPLATE.format(token_filter.__name__,
ngram_range)
filename_index_path = cls._CACHED_FILENAME_PATH_TEMPLATE.format(token_filter.__name__, ngram_range)
if use_cached:
X, y = load_svmlight_file(feature_file_path)
with open(feature_name_index_file_path, 'r') as file, open(filename_index_path, 'r') as filename_index_file:
feature_name_index = json.load(file)
filename_index = json.load(filename_index_file)
else:
labels_dict = cls._parse_labels()
all_email_files = os.listdir(cls._SPAM_EMAIL_DATA_DIR_PATH)
results = Utils.run_tasks_parallelly_in_chunks(cls._get_email_contents_and_labels, all_email_files, 12,
# multi_process=False,
labels_dict=labels_dict,
token_filter=token_filter)
corpus = []
all_labels = []
for email_contents, labels in results:
corpus.extend(email_contents)
all_labels.extend(labels)
if virgil_replies_yes:
vectorizer = CountVectorizer(ngram_range=ngram_range, min_df=0.02, max_df=0.95)
X = vectorizer.fit_transform(corpus)
feature_name_index = vectorizer.get_feature_names()
else:
X, all_labels, feature_name_index = cls._generate_ngrams_using_ES(corpus, all_labels)
y = np.array([label[0] for label in all_labels])
filename_index = [label[1] for label in all_labels]
dump_svmlight_file(X, y, f=feature_file_path)
with open(feature_name_index_file_path, 'w') as file, open(filename_index_path, 'w') as filename_index_file:
json.dump(feature_name_index, file)
json.dump(filename_index, filename_index_file)
indices = np.arange(len(y))
train_ix, test_ix = train_test_split(indices, test_size=0.2, shuffle=True)
filename_index = np.array(filename_index)
X_train, X_test, Y_train, Y_test, test_filename_index = \
X[train_ix, :], X[test_ix, :], y[train_ix], y[test_ix], filename_index[test_ix]
return X_train, X_test, Y_train, Y_test, feature_name_index, test_filename_index
@classmethod
def _run_model(cls, model, model_name, X_train, X_test, Y_train | _get_valid_ngrams | identifier_name |
main.py | SPAM_DATA/trec07p/data'.format("/media/sumeet/147A710C7A70EBBC")
_SPAM_EMAIL_LABELS_PATH = '{}/SPAM_DATA/trec07p/full/index'.format("/media/sumeet/147A710C7A70EBBC")
_CACHED_FEATURE_INDEX_NAME_TEMPLATE = 'feature_matrix_cache/{}-{}-feature_index.json'
_CACHED_FEATURES_FILE_PATH_TEMPLATE = 'feature_matrix_cache/{}-{}-features.txt'
_CACHED_FILENAME_PATH_TEMPLATE = 'feature_matrix_cache/{}-{}-filename_index.txt'
_SPLIT_REGEX = re.compile("\\s+")
_PUNCTUATION_TABLE = str.maketrans('', '', string.punctuation)
_STOPWORDS_SET = set(stopwords.words('english'))
_STEMMER = SnowballStemmer('english')
_PART_1_TRIAL_A_TOKENS_SET = None
_PART_1_TRIAL_B_TOKENS_SET = None
@classmethod
@timing
def _parse_labels(cls) -> Dict[str, int]:
logging.info("Parsing labels")
labels_dict = {}
with open(cls._SPAM_EMAIL_LABELS_PATH, 'r') as file:
for line in file:
parts = re.split(cls._SPLIT_REGEX, line)
if parts[0] == 'spam':
label = 1
elif parts[0] == 'ham':
label = 0
else:
raise ValueError("Invalid label")
file_name = parts[1].split("/")[-1]
labels_dict[file_name] = label
logging.info("{} Labels parsed".format(len(labels_dict)))
return labels_dict
@classmethod
def _text_cleaning_helper(cls, text_to_clean):
cleaned_tokens = []
tokens = word_tokenize(text_to_clean)
for token in tokens:
lowered_token = token.lower()
stripped_token = lowered_token.translate(cls._PUNCTUATION_TABLE)
if stripped_token.isalpha() and stripped_token not in cls._STOPWORDS_SET:
cleaned_tokens.append(cls._STEMMER.stem(stripped_token))
return cleaned_tokens
@classmethod
def _clean_email(cls, raw_email: Email) -> Email:
raw_email.cleaned_subject_tokens = cls._text_cleaning_helper(raw_email.subject)
raw_email.cleaned_body_tokens = cls._text_cleaning_helper(raw_email.body)
return raw_email
@classmethod
def _get_emails(cls, email_files):
for email_file in email_files:
email_file_path = '{}/{}'.format(cls._SPAM_EMAIL_DATA_DIR_PATH, email_file)
with open(email_file_path, 'r', encoding='ISO-8859-1') as email_file_fp:
parsed_raw_email = cls._parse_raw_email(email_file_fp)
parsed_raw_email.file_name = email_file
cleaned_email = cls._clean_email(parsed_raw_email)
yield cleaned_email
@classmethod
def _parse_email_payload_from_html(cls, raw_html) -> str:
bs = BeautifulSoup(raw_html, 'html.parser')
return bs.get_text().strip()
@classmethod
def _parse_raw_email(cls, email_file_fp) -> Email:
def _helper(email_body):
content_type = str(email_body.get_content_type())
content_disposition = str(email_body.get_content_disposition())
if content_type == 'text/plain' and 'attachment' not in content_disposition:
parsed_email.body += str(email_body.get_payload())
elif content_type == 'text/html' and 'attachment' not in content_disposition:
parsed_email.body += cls._parse_email_payload_from_html(str(email_body.get_payload()))
body = email.message_from_file(email_file_fp)
parsed_email = Email()
if body['subject']:
parsed_email.subject = body['subject']
if body.is_multipart():
for part in body.walk():
|
else:
_helper(body)
return parsed_email
@classmethod
def _get_email_contents_and_labels(cls, email_files, labels_dict, token_filter):
ix = 1
email_contents = []
labels = []
for cleaned_email in cls._get_emails(email_files):
ix += 1
text = " ".join(filter(token_filter,
cleaned_email.cleaned_subject_tokens + cleaned_email.cleaned_body_tokens))
if text:
email_contents.append(text)
file_name = cleaned_email.file_name
labels.append((labels_dict[file_name], file_name))
if ix % 1000 == 0:
logging.info("Emails Read :{}".format(ix))
return email_contents, labels
@classmethod
def _generate_ngrams_using_ES(cls, corpus, all_labels):
def _mtermvector_query_helper(text_chunks):
return {
"docs": [
{"doc": {"text": text}} for text in text_chunks
]
}
def _get_valid_ngrams(min_df=0.02, max_df=0.95):
min_df_value = int(min_df * len(corpus))
max_df_value = int(max_df * len(corpus))
_valid_ngrams = set()
for ngram, no_of_documents in all_ngrams.items():
if min_df_value < no_of_documents < max_df_value:
_valid_ngrams.add(ngram)
return _valid_ngrams
es_client = EsUtils.get_es_client()
all_ngrams = defaultdict(int)
docs = []
indptr = [0]
indices = []
data = []
vocabulary = {}
labels = []
ix = 0
for email_content_chunks in Utils.split_list_into_sub_lists(corpus, sub_list_size=5000):
response = es_client.mtermvectors(index=Constants.AP_DATA_INDEX_NAME,
body=_mtermvector_query_helper(email_content_chunks))
for response_obj in response['docs']:
ngrams = {}
termvectors = response_obj['term_vectors']
if 'text' in termvectors:
for term, term_info in termvectors['text']['terms'].items():
ngrams[term] = term_info['term_freq']
all_ngrams[term] += 1
docs.append(ngrams)
labels.append(all_labels[ix])
ix += 1
valid_ngrams = _get_valid_ngrams()
for d in docs:
for term, count in d.items():
if term in valid_ngrams:
index = vocabulary.setdefault(term, len(vocabulary))
indices.append(index)
data.append(count)
indptr.append(len(indices))
features = csr_matrix((data, indices, indptr), dtype=int)
np.testing.assert_equal(features.shape[0], len(labels))
return features, labels, list(vocabulary.keys())
@classmethod
@timing
def _generate_features(cls, token_filter, use_cached=True, ngram_range=(1, 1), virgil_replies_yes=False):
feature_file_path = cls._CACHED_FEATURES_FILE_PATH_TEMPLATE.format(token_filter.__name__, ngram_range)
feature_name_index_file_path = cls._CACHED_FEATURE_INDEX_NAME_TEMPLATE.format(token_filter.__name__,
ngram_range)
filename_index_path = cls._CACHED_FILENAME_PATH_TEMPLATE.format(token_filter.__name__, ngram_range)
if use_cached:
X, y = load_svmlight_file(feature_file_path)
with open(feature_name_index_file_path, 'r') as file, open(filename_index_path, 'r') as filename_index_file:
feature_name_index = json.load(file)
filename_index = json.load(filename_index_file)
else:
labels_dict = cls._parse_labels()
all_email_files = os.listdir(cls._SPAM_EMAIL_DATA_DIR_PATH)
results = Utils.run_tasks_parallelly_in_chunks(cls._get_email_contents_and_labels, all_email_files, 12,
# multi_process=False,
labels_dict=labels_dict,
token_filter=token_filter)
corpus = []
all_labels = []
for email_contents, labels in results:
corpus.extend(email_contents)
all_labels.extend(labels)
if virgil_replies_yes:
vectorizer = CountVectorizer(ngram_range=ngram_range, min_df=0.02, max_df=0.95)
X = vectorizer.fit_transform(corpus)
feature_name_index = vectorizer.get_feature_names()
else:
X, all_labels, feature_name_index = cls._generate_ngrams_using_ES(corpus, all_labels)
y = np.array([label[0] for label in all_labels])
filename_index = [label[1] for label in all_labels]
dump_svmlight_file(X, y, f=feature_file_path)
with open(feature_name_index_file_path, 'w') as file, open(filename_index_path, 'w') as filename_index_file:
json.dump(feature_name_index, file)
json.dump(filename_index, filename_index_file)
indices = np.arange(len(y))
train_ix, test_ix = train_test_split(indices, test_size=0.2, shuffle=True)
filename_index = np.array(filename_index)
X_train, X_test, Y_train, Y_test, test_filename_index = \
X[train_ix, :], X[test_ix, :], y[train_ix], y[test_ix], filename_index[test_ix]
return X_train, X_test, Y_train, Y_test, feature_name_index, test_filename_index
@classmethod
def _run_model(cls, model, model_name, X_train, X_test, Y_train | _helper(part) | conditional_block |
main.py | import random
import re
import string
from collections import defaultdict
from typing import Dict
import numpy as np
from bs4 import BeautifulSoup
from nltk import SnowballStemmer
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from scipy.sparse import csr_matrix
from sklearn.datasets import dump_svmlight_file, load_svmlight_file
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import BernoulliNB
from sklearn.tree import DecisionTreeClassifier
from HW_1.es_utils import EsUtils
from constants.constants import Constants
from utils.decorators import timing
from utils.utils import Utils
class Email:
def __init__(self) -> None:
self.subject = ''
self.body = ''
self.cleaned_subject_tokens = None
self.cleaned_body_tokens = None
self.file_name = None
def __repr__(self) -> str:
return "File: {file_name}, Subject: {subject}, Body: {body}" \
"C_Subject:{cleaned_subject_tokens}, C_Body:{cleaned_body_tokens}".format(**self.__dict__)
def __str__(self):
return self.__repr__()
class HW7:
_SPAM_EMAIL_DATA_DIR_PATH = '{}/SPAM_DATA/trec07p/data'.format("/media/sumeet/147A710C7A70EBBC")
_SPAM_EMAIL_LABELS_PATH = '{}/SPAM_DATA/trec07p/full/index'.format("/media/sumeet/147A710C7A70EBBC")
_CACHED_FEATURE_INDEX_NAME_TEMPLATE = 'feature_matrix_cache/{}-{}-feature_index.json'
_CACHED_FEATURES_FILE_PATH_TEMPLATE = 'feature_matrix_cache/{}-{}-features.txt'
_CACHED_FILENAME_PATH_TEMPLATE = 'feature_matrix_cache/{}-{}-filename_index.txt'
_SPLIT_REGEX = re.compile("\\s+")
_PUNCTUATION_TABLE = str.maketrans('', '', string.punctuation)
_STOPWORDS_SET = set(stopwords.words('english'))
_STEMMER = SnowballStemmer('english')
_PART_1_TRIAL_A_TOKENS_SET = None
_PART_1_TRIAL_B_TOKENS_SET = None
@classmethod
@timing
def _parse_labels(cls) -> Dict[str, int]:
logging.info("Parsing labels")
labels_dict = {}
with open(cls._SPAM_EMAIL_LABELS_PATH, 'r') as file:
for line in file:
parts = re.split(cls._SPLIT_REGEX, line)
if parts[0] == 'spam':
label = 1
elif parts[0] == 'ham':
label = 0
else:
raise ValueError("Invalid label")
file_name = parts[1].split("/")[-1]
labels_dict[file_name] = label
logging.info("{} Labels parsed".format(len(labels_dict)))
return labels_dict
@classmethod
def _text_cleaning_helper(cls, text_to_clean):
cleaned_tokens = []
tokens = word_tokenize(text_to_clean)
for token in tokens:
lowered_token = token.lower()
stripped_token = lowered_token.translate(cls._PUNCTUATION_TABLE)
if stripped_token.isalpha() and stripped_token not in cls._STOPWORDS_SET:
cleaned_tokens.append(cls._STEMMER.stem(stripped_token))
return cleaned_tokens
@classmethod
def _clean_email(cls, raw_email: Email) -> Email:
raw_email.cleaned_subject_tokens = cls._text_cleaning_helper(raw_email.subject)
raw_email.cleaned_body_tokens = cls._text_cleaning_helper(raw_email.body)
return raw_email
@classmethod
def _get_emails(cls, email_files):
for email_file in email_files:
email_file_path = '{}/{}'.format(cls._SPAM_EMAIL_DATA_DIR_PATH, email_file)
with open(email_file_path, 'r', encoding='ISO-8859-1') as email_file_fp:
parsed_raw_email = cls._parse_raw_email(email_file_fp)
parsed_raw_email.file_name = email_file
cleaned_email = cls._clean_email(parsed_raw_email)
yield cleaned_email
@classmethod
def _parse_email_payload_from_html(cls, raw_html) -> str:
bs = BeautifulSoup(raw_html, 'html.parser')
return bs.get_text().strip()
@classmethod
def _parse_raw_email(cls, email_file_fp) -> Email:
def _helper(email_body):
content_type = str(email_body.get_content_type())
content_disposition = str(email_body.get_content_disposition())
if content_type == 'text/plain' and 'attachment' not in content_disposition:
parsed_email.body += str(email_body.get_payload())
elif content_type == 'text/html' and 'attachment' not in content_disposition:
parsed_email.body += cls._parse_email_payload_from_html(str(email_body.get_payload()))
body = email.message_from_file(email_file_fp)
parsed_email = Email()
if body['subject']:
parsed_email.subject = body['subject']
if body.is_multipart():
for part in body.walk():
_helper(part)
else:
_helper(body)
return parsed_email
@classmethod
def _get_email_contents_and_labels(cls, email_files, labels_dict, token_filter):
ix = 1
email_contents = []
labels = []
for cleaned_email in cls._get_emails(email_files):
ix += 1
text = " ".join(filter(token_filter,
cleaned_email.cleaned_subject_tokens + cleaned_email.cleaned_body_tokens))
if text:
email_contents.append(text)
file_name = cleaned_email.file_name
labels.append((labels_dict[file_name], file_name))
if ix % 1000 == 0:
logging.info("Emails Read :{}".format(ix))
return email_contents, labels
@classmethod
def _generate_ngrams_using_ES(cls, corpus, all_labels):
def _mtermvector_query_helper(text_chunks):
return {
"docs": [
{"doc": {"text": text}} for text in text_chunks
]
}
def _get_valid_ngrams(min_df=0.02, max_df=0.95):
min_df_value = int(min_df * len(corpus))
max_df_value = int(max_df * len(corpus))
_valid_ngrams = set()
for ngram, no_of_documents in all_ngrams.items():
if min_df_value < no_of_documents < max_df_value:
_valid_ngrams.add(ngram)
return _valid_ngrams
es_client = EsUtils.get_es_client()
all_ngrams = defaultdict(int)
docs = []
indptr = [0]
indices = []
data = []
vocabulary = {}
labels = []
ix = 0
for email_content_chunks in Utils.split_list_into_sub_lists(corpus, sub_list_size=5000):
response = es_client.mtermvectors(index=Constants.AP_DATA_INDEX_NAME,
body=_mtermvector_query_helper(email_content_chunks))
for response_obj in response['docs']:
ngrams = {}
termvectors = response_obj['term_vectors']
if 'text' in termvectors:
for term, term_info in termvectors['text']['terms'].items():
ngrams[term] = term_info['term_freq']
all_ngrams[term] += 1
docs.append(ngrams)
labels.append(all_labels[ix])
ix += 1
valid_ngrams = _get_valid_ngrams()
for d in docs:
for term, count in d.items():
if term in valid_ngrams:
index = vocabulary.setdefault(term, len(vocabulary))
indices.append(index)
data.append(count)
indptr.append(len(indices))
features = csr_matrix((data, indices, indptr), dtype=int)
np.testing.assert_equal(features.shape[0], len(labels))
return features, labels, list(vocabulary.keys())
@classmethod
@timing
def _generate_features(cls, token_filter, use_cached=True, ngram_range=(1, 1), virgil_replies_yes=False):
feature_file_path = cls._CACHED_FEATURES_FILE_PATH_TEMPLATE.format(token_filter.__name__, ngram_range)
feature_name_index_file_path = cls._CACHED_FEATURE_INDEX_NAME_TEMPLATE.format(token_filter.__name__,
ngram_range)
filename_index_path = cls._CACHED_FILENAME_PATH_TEMPLATE.format(token_filter.__name__, ngram_range)
if use_cached:
X, y = load_svmlight_file(feature_file_path)
with open(feature_name_index_file_path, 'r') as file, open(filename_index_path, 'r') as filename_index_file:
feature_name_index = json.load(file)
filename_index = json.load(filename_index_file)
else:
labels_dict = cls._parse_labels()
all_email_files = os.listdir(cls._SPAM_EMAIL_DATA_DIR_PATH)
results = Utils.run_tasks_parallelly_in_chunks(cls._get_email_contents_and_labels, all_email_files, 12,
# multi_process=False,
labels_dict=labels_dict,
token_filter=token_filter)
corpus = []
all_labels = []
for email_contents, labels in results:
corpus.extend(email_contents)
all_labels.extend(labels)
if virgil_replies_yes:
vectorizer = | import os | random_line_split | |
main.py | SPAM_DATA/trec07p/data'.format("/media/sumeet/147A710C7A70EBBC")
_SPAM_EMAIL_LABELS_PATH = '{}/SPAM_DATA/trec07p/full/index'.format("/media/sumeet/147A710C7A70EBBC")
_CACHED_FEATURE_INDEX_NAME_TEMPLATE = 'feature_matrix_cache/{}-{}-feature_index.json'
_CACHED_FEATURES_FILE_PATH_TEMPLATE = 'feature_matrix_cache/{}-{}-features.txt'
_CACHED_FILENAME_PATH_TEMPLATE = 'feature_matrix_cache/{}-{}-filename_index.txt'
_SPLIT_REGEX = re.compile("\\s+")
_PUNCTUATION_TABLE = str.maketrans('', '', string.punctuation)
_STOPWORDS_SET = set(stopwords.words('english'))
_STEMMER = SnowballStemmer('english')
_PART_1_TRIAL_A_TOKENS_SET = None
_PART_1_TRIAL_B_TOKENS_SET = None
@classmethod
@timing
def _parse_labels(cls) -> Dict[str, int]:
logging.info("Parsing labels")
labels_dict = {}
with open(cls._SPAM_EMAIL_LABELS_PATH, 'r') as file:
for line in file:
parts = re.split(cls._SPLIT_REGEX, line)
if parts[0] == 'spam':
label = 1
elif parts[0] == 'ham':
label = 0
else:
raise ValueError("Invalid label")
file_name = parts[1].split("/")[-1]
labels_dict[file_name] = label
logging.info("{} Labels parsed".format(len(labels_dict)))
return labels_dict
@classmethod
def _text_cleaning_helper(cls, text_to_clean):
|
@classmethod
def _clean_email(cls, raw_email: Email) -> Email:
raw_email.cleaned_subject_tokens = cls._text_cleaning_helper(raw_email.subject)
raw_email.cleaned_body_tokens = cls._text_cleaning_helper(raw_email.body)
return raw_email
@classmethod
def _get_emails(cls, email_files):
for email_file in email_files:
email_file_path = '{}/{}'.format(cls._SPAM_EMAIL_DATA_DIR_PATH, email_file)
with open(email_file_path, 'r', encoding='ISO-8859-1') as email_file_fp:
parsed_raw_email = cls._parse_raw_email(email_file_fp)
parsed_raw_email.file_name = email_file
cleaned_email = cls._clean_email(parsed_raw_email)
yield cleaned_email
@classmethod
def _parse_email_payload_from_html(cls, raw_html) -> str:
bs = BeautifulSoup(raw_html, 'html.parser')
return bs.get_text().strip()
@classmethod
def _parse_raw_email(cls, email_file_fp) -> Email:
def _helper(email_body):
content_type = str(email_body.get_content_type())
content_disposition = str(email_body.get_content_disposition())
if content_type == 'text/plain' and 'attachment' not in content_disposition:
parsed_email.body += str(email_body.get_payload())
elif content_type == 'text/html' and 'attachment' not in content_disposition:
parsed_email.body += cls._parse_email_payload_from_html(str(email_body.get_payload()))
body = email.message_from_file(email_file_fp)
parsed_email = Email()
if body['subject']:
parsed_email.subject = body['subject']
if body.is_multipart():
for part in body.walk():
_helper(part)
else:
_helper(body)
return parsed_email
@classmethod
def _get_email_contents_and_labels(cls, email_files, labels_dict, token_filter):
ix = 1
email_contents = []
labels = []
for cleaned_email in cls._get_emails(email_files):
ix += 1
text = " ".join(filter(token_filter,
cleaned_email.cleaned_subject_tokens + cleaned_email.cleaned_body_tokens))
if text:
email_contents.append(text)
file_name = cleaned_email.file_name
labels.append((labels_dict[file_name], file_name))
if ix % 1000 == 0:
logging.info("Emails Read :{}".format(ix))
return email_contents, labels
@classmethod
def _generate_ngrams_using_ES(cls, corpus, all_labels):
def _mtermvector_query_helper(text_chunks):
return {
"docs": [
{"doc": {"text": text}} for text in text_chunks
]
}
def _get_valid_ngrams(min_df=0.02, max_df=0.95):
min_df_value = int(min_df * len(corpus))
max_df_value = int(max_df * len(corpus))
_valid_ngrams = set()
for ngram, no_of_documents in all_ngrams.items():
if min_df_value < no_of_documents < max_df_value:
_valid_ngrams.add(ngram)
return _valid_ngrams
es_client = EsUtils.get_es_client()
all_ngrams = defaultdict(int)
docs = []
indptr = [0]
indices = []
data = []
vocabulary = {}
labels = []
ix = 0
for email_content_chunks in Utils.split_list_into_sub_lists(corpus, sub_list_size=5000):
response = es_client.mtermvectors(index=Constants.AP_DATA_INDEX_NAME,
body=_mtermvector_query_helper(email_content_chunks))
for response_obj in response['docs']:
ngrams = {}
termvectors = response_obj['term_vectors']
if 'text' in termvectors:
for term, term_info in termvectors['text']['terms'].items():
ngrams[term] = term_info['term_freq']
all_ngrams[term] += 1
docs.append(ngrams)
labels.append(all_labels[ix])
ix += 1
valid_ngrams = _get_valid_ngrams()
for d in docs:
for term, count in d.items():
if term in valid_ngrams:
index = vocabulary.setdefault(term, len(vocabulary))
indices.append(index)
data.append(count)
indptr.append(len(indices))
features = csr_matrix((data, indices, indptr), dtype=int)
np.testing.assert_equal(features.shape[0], len(labels))
return features, labels, list(vocabulary.keys())
@classmethod
@timing
def _generate_features(cls, token_filter, use_cached=True, ngram_range=(1, 1), virgil_replies_yes=False):
feature_file_path = cls._CACHED_FEATURES_FILE_PATH_TEMPLATE.format(token_filter.__name__, ngram_range)
feature_name_index_file_path = cls._CACHED_FEATURE_INDEX_NAME_TEMPLATE.format(token_filter.__name__,
ngram_range)
filename_index_path = cls._CACHED_FILENAME_PATH_TEMPLATE.format(token_filter.__name__, ngram_range)
if use_cached:
X, y = load_svmlight_file(feature_file_path)
with open(feature_name_index_file_path, 'r') as file, open(filename_index_path, 'r') as filename_index_file:
feature_name_index = json.load(file)
filename_index = json.load(filename_index_file)
else:
labels_dict = cls._parse_labels()
all_email_files = os.listdir(cls._SPAM_EMAIL_DATA_DIR_PATH)
results = Utils.run_tasks_parallelly_in_chunks(cls._get_email_contents_and_labels, all_email_files, 12,
# multi_process=False,
labels_dict=labels_dict,
token_filter=token_filter)
corpus = []
all_labels = []
for email_contents, labels in results:
corpus.extend(email_contents)
all_labels.extend(labels)
if virgil_replies_yes:
vectorizer = CountVectorizer(ngram_range=ngram_range, min_df=0.02, max_df=0.95)
X = vectorizer.fit_transform(corpus)
feature_name_index = vectorizer.get_feature_names()
else:
X, all_labels, feature_name_index = cls._generate_ngrams_using_ES(corpus, all_labels)
y = np.array([label[0] for label in all_labels])
filename_index = [label[1] for label in all_labels]
dump_svmlight_file(X, y, f=feature_file_path)
with open(feature_name_index_file_path, 'w') as file, open(filename_index_path, 'w') as filename_index_file:
json.dump(feature_name_index, file)
json.dump(filename_index, filename_index_file)
indices = np.arange(len(y))
train_ix, test_ix = train_test_split(indices, test_size=0.2, shuffle=True)
filename_index = np.array(filename_index)
X_train, X_test, Y_train, Y_test, test_filename_index = \
X[train_ix, :], X[test_ix, :], y[train_ix], y[test_ix], filename_index[test_ix]
return X_train, X_test, Y_train, Y_test, feature_name_index, test_filename_index
@classmethod
def _run_model(cls, model, model_name, X_train, X_test, Y | cleaned_tokens = []
tokens = word_tokenize(text_to_clean)
for token in tokens:
lowered_token = token.lower()
stripped_token = lowered_token.translate(cls._PUNCTUATION_TABLE)
if stripped_token.isalpha() and stripped_token not in cls._STOPWORDS_SET:
cleaned_tokens.append(cls._STEMMER.stem(stripped_token))
return cleaned_tokens | identifier_body |
func.py |
def rankdata(arr, axis=None):
"Slow rankdata function used for unaccelerated ndim/dtype combinations."
arr = np.asarray(arr)
if axis is None:
arr = arr.ravel()
axis = 0
elif axis < 0:
axis = range(arr.ndim)[axis]
y = np.empty(arr.shape)
itshape = list(arr.shape)
itshape.pop(axis)
for ij in np.ndindex(*itshape):
ijslice = list(ij[:axis]) + [slice(None)] + list(ij[axis:])
y[ijslice] = scipy_rankdata(arr[ijslice].astype('float'))
return y
def nanrankdata(arr, axis=None):
"Slow nanrankdata function used for unaccelerated ndim/dtype combinations."
arr = np.asarray(arr)
if axis is None:
arr = arr.ravel()
axis = 0
elif axis < 0:
axis = range(arr.ndim)[axis]
y = np.empty(arr.shape)
y.fill(np.nan)
itshape = list(arr.shape)
itshape.pop(axis)
for ij in np.ndindex(*itshape):
ijslice = list(ij[:axis]) + [slice(None)] + list(ij[axis:])
x1d = arr[ijslice].astype(float)
mask1d = ~np.isnan(x1d)
x1d[mask1d] = scipy_rankdata(x1d[mask1d])
y[ijslice] = x1d
return y
def ss(arr, axis=0):
"Slow sum of squares used for unaccelerated ndim/dtype combinations."
return scipy_ss(arr, axis)
def nn(arr, arr0, axis=1):
"Slow nearest neighbor used for unaccelerated ndim/dtype combinations."
arr = np.array(arr, copy=False)
arr0 = np.array(arr0, copy=False)
if arr.ndim != 2:
raise ValueError("`arr` must be 2d")
if arr0.ndim != 1:
raise ValueError("`arr0` must be 1d")
if axis == 1:
d = (arr - arr0) ** 2
elif axis == 0:
d = (arr - arr0.reshape(-1,1)) ** 2
else:
raise ValueError("`axis` must be 0 or 1.")
d = d.sum(axis)
idx = np.argmin(d)
return np.sqrt(d[idx]), idx
def partsort(arr, n, axis=-1):
"Slow partial sort used for unaccelerated ndim/dtype combinations."
return np.sort(arr, axis)
def argpartsort(arr, n, axis=-1):
"Slow partial argsort used for unaccelerated ndim/dtype combinations."
return np.argsort(arr, axis)
def replace(arr, old, new):
"Slow replace (inplace) used for unaccelerated ndim/dtype combinations."
if type(arr) is not np.ndarray:
raise TypeError("`arr` must be a numpy array.")
if not issubclass(arr.dtype.type, np.inexact):
if old != old:
# int arrays do not contain NaN
return
if int(old) != old:
raise ValueError("Cannot safely cast `old` to int.")
if int(new) != new:
raise ValueError("Cannot safely cast `new` to int.")
if old != old:
mask = np.isnan(arr)
else:
mask = arr == old
np.putmask(arr, mask, new)
def anynan(arr, axis=None):
"Slow check for Nans used for unaccelerated ndim/dtype combinations."
return np.isnan(arr).any(axis)
def allnan(arr, axis=None):
"Slow check for all Nans used for unaccelerated ndim/dtype combinations."
return np.isnan(arr).all(axis)
def nanequal(arr1, arr2, axis=None):
"Slow check for equality that ignores NaNs"
if axis is None:
nans = np.isnan(arr1) | np.isnan(arr2)
return np.array_equal(arr1[~nans], arr2[~nans])
if arr1.size == 0:
if axis < 0:
axis += arr1.ndim
return np.ones(arr1.shape[:axis]+arr1.shape[axis+1:], np.bool)
if arr1.size == 1:
return arr1 == arr2 or arr1 != arr1 or arr2 != arr2
return np.apply_along_axis(lambda x:nanequal(x["f0"], x["f1"]), axis,
np.core.records.fromarrays([arr1, arr2]))
def bincount(arr, max_val, weights=None, mask=None):
"Slow bincount"
if arr.ndim == 1:
out = np.zeros((max_val+1, ), float)
nans = 0.0
if mask is None or mask[0]:
for i, ai in enumerate(arr):
if ai != ai:
nans += 1 if weights is None else weights[i]
continue
ain = int(ai+0.1)
if abs(ain - ai) > 1e-6:
raise ValueError("%f is not integer" % ain)
if ain < 0:
raise ValueError("negative value in bincount")
if ain > max_val:
raise ValueError("value %i is greater than max_val (%i)" %
(ain, max_val))
out[ain] += 1 if weights is None else weights[i]
elif arr.ndim == 2:
out = np.zeros((arr.shape[1], max_val+1), float)
nans = np.zeros((arr.shape[1], ), float)
if sp.issparse(arr):
indptr, indices, data = arr.indptr, arr.indices, arr.data
for ri in range(arr.shape[0]):
wt = 1 if weights is None else weights[ri]
for i in range(indptr[ri], indptr[ri + 1]):
ci = indices[i]
if mask is None or mask[ci]:
out[ci, data[i]] += wt
else:
for i in range(arr.shape[1]):
if mask is None or mask[i]:
out[i, :], nans[i] = bincount(arr[:, i], max_val, weights)
else:
raise ValueError("bincount expects 1- or 2-dimensional array")
return out, nans
def contingency(arr, b, max_val, max_val2, weights=None, mask=None):
raise NotImplemented("bottlechest.slow.contingency is not implemented yet")
def valuecount(arr):
"slow valuecount"
if arr.ndim != 2 or arr.shape[0] != 2:
raise ValueError("valuecount expects an array with shape (2, N)")
N = arr.shape[1]
dst = 0
for src in range(1, N):
if math.isnan(arr[0, src]):
break
if arr[0, src] == arr[0, dst]:
arr[1, dst] += arr[1, src]
else:
dst += 1
arr[:, dst] = arr[:, src]
return arr[:, :dst + 1]
def countnans(arr, weights=None, axis=None):
if axis is None:
if weights is None:
return np.sum(np.isnan(arr))
else:
return np.sum(np.isnan(arr)*weights)
else:
if weights is not None:
if arr.shape[axis] != len(weights):
raise ValueError("shape of weights does not match the data")
return np.apply_along_axis(lambda a: np.sum(np.isnan(a)*weights),
axis, arr)
else:
return np.sum(np.isnan(arr), axis=axis)
def stats_object(arr, weights=None):
pinf, minf = float("inf"), float("-inf")
if arr.ndim == 1:
if weights is None:
nones = sum(np.equal(arr, None))
return pinf, minf, 0, 0, nones, len(arr) - nones
else:
nones = sum(np.equal(arr, None) * weights)
return pinf, minf, 0, 0, nones, sum(weights) - nones
if sp.issparse(arr) and weights is not None:
raise NotImplementedError("counting of missing values for"
"weighted arrays of type 'object' is not implemented")
y = np.zeros((arr.shape[1], 6), float)
y[:, 0] = pinf
y[:, 1] = minf
if sp.issparse(arr):
y[:, 4] = np.bincount(arr.indices, minlength=arr.shape[1])
elif weights is None:
y[:, 4] = np.sum(np.equal(arr, None), axis=0)
else:
y[:, 4] = np.sum(np.equal(arr, None) * weights[:, np.newaxis], axis=0)
y[:, 5] = arr.shape[0] - y[:, 4]
return y
def stats | "Slow nanargmax function used for unaccelerated ndim/dtype combinations."
with warnings.catch_warnings():
warnings.simplefilter("ignore")
return np.nanargmax(arr, axis=axis) | identifier_body | |
func.py | itshape):
ijslice = list(ij[:axis]) + [slice(None)] + list(ij[axis:])
x1d = arr[ijslice].astype(float)
mask1d = ~np.isnan(x1d)
x1d[mask1d] = scipy_rankdata(x1d[mask1d])
y[ijslice] = x1d
return y
def ss(arr, axis=0):
"Slow sum of squares used for unaccelerated ndim/dtype combinations."
return scipy_ss(arr, axis)
def nn(arr, arr0, axis=1):
"Slow nearest neighbor used for unaccelerated ndim/dtype combinations."
arr = np.array(arr, copy=False)
arr0 = np.array(arr0, copy=False)
if arr.ndim != 2:
raise ValueError("`arr` must be 2d")
if arr0.ndim != 1:
raise ValueError("`arr0` must be 1d")
if axis == 1:
d = (arr - arr0) ** 2
elif axis == 0:
d = (arr - arr0.reshape(-1,1)) ** 2
else:
raise ValueError("`axis` must be 0 or 1.")
d = d.sum(axis)
idx = np.argmin(d)
return np.sqrt(d[idx]), idx
def partsort(arr, n, axis=-1):
"Slow partial sort used for unaccelerated ndim/dtype combinations."
return np.sort(arr, axis)
def argpartsort(arr, n, axis=-1):
"Slow partial argsort used for unaccelerated ndim/dtype combinations."
return np.argsort(arr, axis)
def replace(arr, old, new):
"Slow replace (inplace) used for unaccelerated ndim/dtype combinations."
if type(arr) is not np.ndarray:
raise TypeError("`arr` must be a numpy array.")
if not issubclass(arr.dtype.type, np.inexact):
if old != old:
# int arrays do not contain NaN
return
if int(old) != old:
raise ValueError("Cannot safely cast `old` to int.")
if int(new) != new:
raise ValueError("Cannot safely cast `new` to int.")
if old != old:
mask = np.isnan(arr)
else:
mask = arr == old
np.putmask(arr, mask, new)
def anynan(arr, axis=None):
"Slow check for Nans used for unaccelerated ndim/dtype combinations."
return np.isnan(arr).any(axis)
def allnan(arr, axis=None):
"Slow check for all Nans used for unaccelerated ndim/dtype combinations."
return np.isnan(arr).all(axis)
def nanequal(arr1, arr2, axis=None):
"Slow check for equality that ignores NaNs"
if axis is None:
nans = np.isnan(arr1) | np.isnan(arr2)
return np.array_equal(arr1[~nans], arr2[~nans])
if arr1.size == 0:
if axis < 0:
axis += arr1.ndim
return np.ones(arr1.shape[:axis]+arr1.shape[axis+1:], np.bool)
if arr1.size == 1:
return arr1 == arr2 or arr1 != arr1 or arr2 != arr2
return np.apply_along_axis(lambda x:nanequal(x["f0"], x["f1"]), axis,
np.core.records.fromarrays([arr1, arr2]))
def bincount(arr, max_val, weights=None, mask=None):
"Slow bincount"
if arr.ndim == 1:
out = np.zeros((max_val+1, ), float)
nans = 0.0
if mask is None or mask[0]:
for i, ai in enumerate(arr):
if ai != ai:
nans += 1 if weights is None else weights[i]
continue
ain = int(ai+0.1)
if abs(ain - ai) > 1e-6:
raise ValueError("%f is not integer" % ain)
if ain < 0:
raise ValueError("negative value in bincount")
if ain > max_val:
raise ValueError("value %i is greater than max_val (%i)" %
(ain, max_val))
out[ain] += 1 if weights is None else weights[i]
elif arr.ndim == 2:
out = np.zeros((arr.shape[1], max_val+1), float)
nans = np.zeros((arr.shape[1], ), float)
if sp.issparse(arr):
indptr, indices, data = arr.indptr, arr.indices, arr.data
for ri in range(arr.shape[0]):
wt = 1 if weights is None else weights[ri]
for i in range(indptr[ri], indptr[ri + 1]):
ci = indices[i]
if mask is None or mask[ci]:
out[ci, data[i]] += wt
else:
for i in range(arr.shape[1]):
if mask is None or mask[i]:
out[i, :], nans[i] = bincount(arr[:, i], max_val, weights)
else:
raise ValueError("bincount expects 1- or 2-dimensional array")
return out, nans
def contingency(arr, b, max_val, max_val2, weights=None, mask=None):
raise NotImplemented("bottlechest.slow.contingency is not implemented yet")
def valuecount(arr):
"slow valuecount"
if arr.ndim != 2 or arr.shape[0] != 2:
raise ValueError("valuecount expects an array with shape (2, N)")
N = arr.shape[1]
dst = 0
for src in range(1, N):
if math.isnan(arr[0, src]):
break
if arr[0, src] == arr[0, dst]:
arr[1, dst] += arr[1, src]
else:
dst += 1
arr[:, dst] = arr[:, src]
return arr[:, :dst + 1]
def countnans(arr, weights=None, axis=None):
if axis is None:
if weights is None:
return np.sum(np.isnan(arr))
else:
return np.sum(np.isnan(arr)*weights)
else:
if weights is not None:
if arr.shape[axis] != len(weights):
raise ValueError("shape of weights does not match the data")
return np.apply_along_axis(lambda a: np.sum(np.isnan(a)*weights),
axis, arr)
else:
return np.sum(np.isnan(arr), axis=axis)
def stats_object(arr, weights=None):
pinf, minf = float("inf"), float("-inf")
if arr.ndim == 1:
if weights is None:
nones = sum(np.equal(arr, None))
return pinf, minf, 0, 0, nones, len(arr) - nones
else:
nones = sum(np.equal(arr, None) * weights)
return pinf, minf, 0, 0, nones, sum(weights) - nones
if sp.issparse(arr) and weights is not None:
raise NotImplementedError("counting of missing values for"
"weighted arrays of type 'object' is not implemented")
y = np.zeros((arr.shape[1], 6), float)
y[:, 0] = pinf
y[:, 1] = minf
if sp.issparse(arr):
y[:, 4] = np.bincount(arr.indices, minlength=arr.shape[1])
elif weights is None:
y[:, 4] = np.sum(np.equal(arr, None), axis=0)
else:
y[:, 4] = np.sum(np.equal(arr, None) * weights[:, np.newaxis], axis=0)
y[:, 5] = arr.shape[0] - y[:, 4]
return y
def stats(arr, weights=None, compute_variance=False):
if not 1 <= arr.ndim <= 2:
raise ValueError("bottlechest.stats handles only 1-d and 2-d arrays")
if arr.dtype == object:
# can't compute min and max, but we can count 'nans'
return stats_object(arr, weights)
if arr.ndim == 1:
a_min, a_max = np.nanmin(arr), np.nanmax(arr)
if weights is None:
nans = np.sum(np.isnan(arr))
non_nans = len(arr) - nans
mean = np.nansum(arr) / non_nans
var = np.nansum((arr - mean) ** 2) / (non_nans - 1)
else:
tot_w = np.sum(weights)
nans = np.sum(np.isnan(arr) * weights)
non_nans = tot_w - nans
mean = np.nansum(arr * weights) / non_nans
var = np.nansum(weights * (arr - mean) ** 2)
tot_w2 = np.sum((1 - np.isnan(arr)) * weights ** 2)
d = non_nans ** 2 - tot_w2
if d > 1e-6:
|
return a_min, a_max, | var *= non_nans / d | conditional_block |
func.py | _max = np.nanmin(arr), np.nanmax(arr)
if weights is None:
nans = np.sum(np.isnan(arr))
non_nans = len(arr) - nans
mean = np.nansum(arr) / non_nans
var = np.nansum((arr - mean) ** 2) / (non_nans - 1)
else:
tot_w = np.sum(weights)
nans = np.sum(np.isnan(arr) * weights)
non_nans = tot_w - nans
mean = np.nansum(arr * weights) / non_nans
var = np.nansum(weights * (arr - mean) ** 2)
tot_w2 = np.sum((1 - np.isnan(arr)) * weights ** 2)
d = non_nans ** 2 - tot_w2
if d > 1e-6:
var *= non_nans / d
return a_min, a_max, mean, var, nans, non_nans
if sp.issparse(arr):
arr = arr.todense()
y = np.zeros((arr.shape[1], 6), dtype=float)
y[:, 0] = nanmin(arr, 0)
y[:, 1] = nanmax(arr, 0)
if weights:
tot_w = np.sum(weights)
y[:, 4] = countnans(arr, weights, 0)
y[:, 5] = tot_w - y[:, 4]
y[:, 2] = nanmean(arr * weights, 0) / y[:, 4]
y[:, 3] = nansum(weights * (arr - y[:, 2]) ** 2, 0)
tot_w2 = np.sum((1 - np.isnan(arr)) * weights ** 2)
d = y[:, 5] ** 2 - tot_w2
if d > 1e-6:
y[:, 3] *= y[:, 5] / d
else:
y[:, 4] = countnans(arr, axis=0)
y[:, 5] = arr.shape[0] - y[:, 4]
y[:, 2] = nanmean(arr, 0) / y[:, 4]
y[:, 3] = nansum((arr - y[:, 2]) ** 2, 0) / (y[:, 4] - 1)
y[:, 2][np.isinf(y[:, 2])] = 0
return y
# ---------------------------------------------------------------------------
#
# SciPy
#
# Local copy of scipy.stats functions to avoid (by popular demand) a SciPy
# dependency. The SciPy license is included in the Bottleneck license file,
# which is distributed with Bottleneck.
#
# Code taken from scipy trunk on Dec 16, 2010.
# nanmedian taken from scipy trunk on Dec 17, 2010.
# rankdata taken from scipy HEAD on Mar 16, 2011.
def scipy_nanmean(x, axis=0):
"""
Compute the mean over the given axis ignoring nans.
Parameters
----------
x : ndarray
Input array.
axis : int, optional
Axis along which the mean is computed. Default is 0, i.e. the
first axis.
Returns
-------
m : float
The mean of `x`, ignoring nans.
See Also
--------
nanstd, nanmedian
Examples
--------
>>> from scipy import stats
>>> a = np.linspace(0, 4, 3)
>>> a
array([ 0., 2., 4.])
>>> a[-1] = np.nan
>>> stats.nanmean(a)
1.0
"""
x, axis = _chk_asarray(x,axis)
x = x.copy()
Norig = x.shape[axis]
factor = 1.0-np.sum(np.isnan(x),axis)*1.0/Norig
x[np.isnan(x)] = 0
return np.mean(x,axis)/factor
def scipy_nanstd(x, axis=0, bias=False):
"""
Compute the standard deviation over the given axis, ignoring nans.
Parameters
----------
x : array_like
Input array.
axis : int or None, optional
Axis along which the standard deviation is computed. Default is 0.
If None, compute over the whole array `x`.
bias : bool, optional
If True, the biased (normalized by N) definition is used. If False
(default), the unbiased definition is used.
Returns
-------
s : float
The standard deviation.
See Also
--------
nanmean, nanmedian
Examples
--------
>>> from scipy import stats
>>> a = np.arange(10, dtype=float)
>>> a[1:3] = np.nan
>>> np.std(a)
nan
>>> stats.nanstd(a)
2.9154759474226504
>>> stats.nanstd(a.reshape(2, 5), axis=1)
array([ 2.0817, 1.5811])
>>> stats.nanstd(a.reshape(2, 5), axis=None)
2.9154759474226504
"""
x, axis = _chk_asarray(x,axis)
x = x.copy()
Norig = x.shape[axis]
Nnan = np.sum(np.isnan(x),axis)*1.0
n = Norig - Nnan
x[np.isnan(x)] = 0.
m1 = np.sum(x,axis)/n
if axis:
d = (x - np.expand_dims(m1, axis))**2.0
else:
d = (x - m1)**2.0
m2 = np.sum(d,axis)-(m1*m1)*Nnan
if bias:
m2c = m2 / n
else:
m2c = m2 / (n - 1.)
return np.sqrt(m2c)
def _nanmedian(arr1d): # This only works on 1d arrays
"""Private function for rank a arrays. Compute the median ignoring Nan.
Parameters
----------
arr1d : ndarray
Input array, of rank 1.
Results
-------
m : float
The median.
"""
cond = 1-np.isnan(arr1d)
x = np.sort(np.compress(cond,arr1d,axis=-1))
if x.size == 0:
return np.nan
return np.median(x)
# Feb 2011: patched nanmedian to handle nanmedian(a, 1) with a = np.ones((2,0))
def scipy_nanmedian(x, axis=0):
"""
Compute the median along the given axis ignoring nan values.
Parameters
----------
x : array_like
Input array.
axis : int, optional
Axis along which the median is computed. Default is 0, i.e. the
first axis.
Returns
-------
m : float
The median of `x` along `axis`.
See Also
--------
nanstd, nanmean
Examples
--------
>>> from scipy import stats
>>> a = np.array([0, 3, 1, 5, 5, np.nan])
>>> stats.nanmedian(a)
array(3.0)
>>> b = np.array([0, 3, 1, 5, 5, np.nan, 5])
>>> stats.nanmedian(b)
array(4.0)
Example with axis:
>>> c = np.arange(30.).reshape(5,6)
>>> idx = np.array([False, False, False, True, False] * 6).reshape(5,6)
>>> c[idx] = np.nan
>>> c
array([[ 0., 1., 2., nan, 4., 5.],
[ 6., 7., nan, 9., 10., 11.],
[ 12., nan, 14., 15., 16., 17.],
[ nan, 19., 20., 21., 22., nan],
[ 24., 25., 26., 27., nan, 29.]])
>>> stats.nanmedian(c, axis=1)
array([ 2. , 9. , 15. , 20.5, 26. ])
"""
x, axis = _chk_asarray(x, axis)
if x.ndim == 0:
return float(x.item())
shape = list(x.shape)
shape.pop(axis)
if 0 in shape:
x = np.empty(shape)
else:
x = x.copy()
x = np.apply_along_axis(_nanmedian, axis, x)
if x.ndim == 0:
x = float(x.item())
return x
def | _chk_asarray | identifier_name | |
func.py | itshape):
ijslice = list(ij[:axis]) + [slice(None)] + list(ij[axis:])
x1d = arr[ijslice].astype(float)
mask1d = ~np.isnan(x1d)
x1d[mask1d] = scipy_rankdata(x1d[mask1d])
y[ijslice] = x1d
return y
def ss(arr, axis=0):
"Slow sum of squares used for unaccelerated ndim/dtype combinations."
return scipy_ss(arr, axis)
def nn(arr, arr0, axis=1):
"Slow nearest neighbor used for unaccelerated ndim/dtype combinations."
arr = np.array(arr, copy=False)
arr0 = np.array(arr0, copy=False)
if arr.ndim != 2:
raise ValueError("`arr` must be 2d")
if arr0.ndim != 1:
raise ValueError("`arr0` must be 1d")
if axis == 1:
d = (arr - arr0) ** 2
elif axis == 0:
d = (arr - arr0.reshape(-1,1)) ** 2
else:
raise ValueError("`axis` must be 0 or 1.") | d = d.sum(axis)
idx = np.argmin(d)
return np.sqrt(d[idx]), idx
def partsort(arr, n, axis=-1):
"Slow partial sort used for unaccelerated ndim/dtype combinations."
return np.sort(arr, axis)
def argpartsort(arr, n, axis=-1):
"Slow partial argsort used for unaccelerated ndim/dtype combinations."
return np.argsort(arr, axis)
def replace(arr, old, new):
"Slow replace (inplace) used for unaccelerated ndim/dtype combinations."
if type(arr) is not np.ndarray:
raise TypeError("`arr` must be a numpy array.")
if not issubclass(arr.dtype.type, np.inexact):
if old != old:
# int arrays do not contain NaN
return
if int(old) != old:
raise ValueError("Cannot safely cast `old` to int.")
if int(new) != new:
raise ValueError("Cannot safely cast `new` to int.")
if old != old:
mask = np.isnan(arr)
else:
mask = arr == old
np.putmask(arr, mask, new)
def anynan(arr, axis=None):
"Slow check for Nans used for unaccelerated ndim/dtype combinations."
return np.isnan(arr).any(axis)
def allnan(arr, axis=None):
"Slow check for all Nans used for unaccelerated ndim/dtype combinations."
return np.isnan(arr).all(axis)
def nanequal(arr1, arr2, axis=None):
"Slow check for equality that ignores NaNs"
if axis is None:
nans = np.isnan(arr1) | np.isnan(arr2)
return np.array_equal(arr1[~nans], arr2[~nans])
if arr1.size == 0:
if axis < 0:
axis += arr1.ndim
return np.ones(arr1.shape[:axis]+arr1.shape[axis+1:], np.bool)
if arr1.size == 1:
return arr1 == arr2 or arr1 != arr1 or arr2 != arr2
return np.apply_along_axis(lambda x:nanequal(x["f0"], x["f1"]), axis,
np.core.records.fromarrays([arr1, arr2]))
def bincount(arr, max_val, weights=None, mask=None):
"Slow bincount"
if arr.ndim == 1:
out = np.zeros((max_val+1, ), float)
nans = 0.0
if mask is None or mask[0]:
for i, ai in enumerate(arr):
if ai != ai:
nans += 1 if weights is None else weights[i]
continue
ain = int(ai+0.1)
if abs(ain - ai) > 1e-6:
raise ValueError("%f is not integer" % ain)
if ain < 0:
raise ValueError("negative value in bincount")
if ain > max_val:
raise ValueError("value %i is greater than max_val (%i)" %
(ain, max_val))
out[ain] += 1 if weights is None else weights[i]
elif arr.ndim == 2:
out = np.zeros((arr.shape[1], max_val+1), float)
nans = np.zeros((arr.shape[1], ), float)
if sp.issparse(arr):
indptr, indices, data = arr.indptr, arr.indices, arr.data
for ri in range(arr.shape[0]):
wt = 1 if weights is None else weights[ri]
for i in range(indptr[ri], indptr[ri + 1]):
ci = indices[i]
if mask is None or mask[ci]:
out[ci, data[i]] += wt
else:
for i in range(arr.shape[1]):
if mask is None or mask[i]:
out[i, :], nans[i] = bincount(arr[:, i], max_val, weights)
else:
raise ValueError("bincount expects 1- or 2-dimensional array")
return out, nans
def contingency(arr, b, max_val, max_val2, weights=None, mask=None):
raise NotImplemented("bottlechest.slow.contingency is not implemented yet")
def valuecount(arr):
"slow valuecount"
if arr.ndim != 2 or arr.shape[0] != 2:
raise ValueError("valuecount expects an array with shape (2, N)")
N = arr.shape[1]
dst = 0
for src in range(1, N):
if math.isnan(arr[0, src]):
break
if arr[0, src] == arr[0, dst]:
arr[1, dst] += arr[1, src]
else:
dst += 1
arr[:, dst] = arr[:, src]
return arr[:, :dst + 1]
def countnans(arr, weights=None, axis=None):
if axis is None:
if weights is None:
return np.sum(np.isnan(arr))
else:
return np.sum(np.isnan(arr)*weights)
else:
if weights is not None:
if arr.shape[axis] != len(weights):
raise ValueError("shape of weights does not match the data")
return np.apply_along_axis(lambda a: np.sum(np.isnan(a)*weights),
axis, arr)
else:
return np.sum(np.isnan(arr), axis=axis)
def stats_object(arr, weights=None):
pinf, minf = float("inf"), float("-inf")
if arr.ndim == 1:
if weights is None:
nones = sum(np.equal(arr, None))
return pinf, minf, 0, 0, nones, len(arr) - nones
else:
nones = sum(np.equal(arr, None) * weights)
return pinf, minf, 0, 0, nones, sum(weights) - nones
if sp.issparse(arr) and weights is not None:
raise NotImplementedError("counting of missing values for"
"weighted arrays of type 'object' is not implemented")
y = np.zeros((arr.shape[1], 6), float)
y[:, 0] = pinf
y[:, 1] = minf
if sp.issparse(arr):
y[:, 4] = np.bincount(arr.indices, minlength=arr.shape[1])
elif weights is None:
y[:, 4] = np.sum(np.equal(arr, None), axis=0)
else:
y[:, 4] = np.sum(np.equal(arr, None) * weights[:, np.newaxis], axis=0)
y[:, 5] = arr.shape[0] - y[:, 4]
return y
def stats(arr, weights=None, compute_variance=False):
if not 1 <= arr.ndim <= 2:
raise ValueError("bottlechest.stats handles only 1-d and 2-d arrays")
if arr.dtype == object:
# can't compute min and max, but we can count 'nans'
return stats_object(arr, weights)
if arr.ndim == 1:
a_min, a_max = np.nanmin(arr), np.nanmax(arr)
if weights is None:
nans = np.sum(np.isnan(arr))
non_nans = len(arr) - nans
mean = np.nansum(arr) / non_nans
var = np.nansum((arr - mean) ** 2) / (non_nans - 1)
else:
tot_w = np.sum(weights)
nans = np.sum(np.isnan(arr) * weights)
non_nans = tot_w - nans
mean = np.nansum(arr * weights) / non_nans
var = np.nansum(weights * (arr - mean) ** 2)
tot_w2 = np.sum((1 - np.isnan(arr)) * weights ** 2)
d = non_nans ** 2 - tot_w2
if d > 1e-6:
var *= non_nans / d
return a_min, a_max, | random_line_split | |
yintai.js | },400);
animate(shangzuos[0],{width:x},400);
animate(xiayous[0],{width:x},400);
}
zw4s.onmouseout=function(){
animate(zuoshangs[0],{height:0},400);
animate(youxias[0],{height:0},400);
animate(shangzuos[0],{width:0},400);
animate(xiayous[0],{width:0},400);
}
}
// 热门品牌动画
var zw4s=$('.zhengwen4')
for (var i = 0; i < zw4s.length; i++) {
paomaxian(zw4s[i],198,250)
};
// 时尚名品动画
var zw4s=$('.shishang8a');
for (var i = 0; i < zw4s.length; i++) {
paomaxian(zw4s[i],272,182)
};
// 热门品牌选项卡
var anniu=getClass('zhengwen3a',document);
var ab=anniu[0].getElementsByTagName('a');
var span1=anniu[0].getElementsByTagName('span');
var zhenwen=getClass('zhengwen4box',document);
for (var i = 0; i < ab.length; i++) {
ab[i].aa=i;
ab[0].style.borderBottom='3px solid red';
span1[0].style.display='block';
zhenwen[0].style.display='block';
ab[i].onmouseover=function(){
for (var j = 0; j < zhenwen.length; j++) {
ab[j].style.borderBottom='';
span1[j].style.display='none';
zhenwen[j].style.display='none';
};
span1[this.aa].style.display='block';
zhenwen[this.aa].style.display='block';
this.style.borderBottom='3px solid red';
};
};
// 时尚名品无缝轮播模式图模式
var box=$('.shishang7');
for(var i=0;i<box.length;i++){
fengzhuang(box[i])
}
function fengzhuang(box){
var n=0;
var next=0;
var boximg=$('.imgbox',box)[0]
var img=$("a",box);
img[0].style.left='0';
var anniu=$('.sh7a',box);
anniu[0].style.background='red';
var btn=$('.shanniu',box)[0];
var left=$('.shleft',btn);
var right=$('.shright',btn);
var iw=parseInt(getStyle(img[0],"width"));
//向左轮播
function lunbo(){
next=n+1;
if (next==img.length) {
return
};
for (var i = 0; i < img.length; i++) {
anniu[i].style.background=''
};
img[next].style.left=iw+'px';
animate(img[n],{left:-iw},700);
animate(img[next],{left:0},700);
anniu[n].style.background=""
anniu[next].style.background='red'
n=next;
};
//向右轮播
function fanxiang(){
next=n-1;
if (next<0) {
return;
};
for (var i = 0; i < img.length; i++) {
anniu[i].style.background=''
};
img[next].style.left=-iw+'px';
animate(img[n],{left:iw},700);
animate(img[next],{left:0},700);
anniu[n].style.background=""
anniu[next].style.background='red'
n=next;
}
anniu[0].onmouseover=function(){
fanxiang();
};
anniu[1].onmouseover=function(){
lunbo();
}
box.onmouseover=function(){
btn.style.display="block"
box.style.opacity='0.8';
}
box.onmouseout=function(){
btn.style.display="none"
box.style.opacity='1';
}
btn.onmousedown=function(){
return false;
}
right[0].onclick=function(){
lunbo();
}
left[0].onclick=function(){
fanxiang();
}
// 无缝轮播
var shishang5=$('.shishang5')
for (var i = 0; i < shishang5.length; i++) {
diaoyong(shishang5[i])
};
function diaoyong(shishang5){
var tupianbox=$('.shishang6',shishang5);
// alert(tupianbox.length)
var leftbtn=$('.shishang6b',shishang5);
var rightbtn=$('.shishang6c',shishang5);
var h=document.documentElement.clientHeight;
var zw=tupianbox[0].offsetWidth;
tupianbox[0].style.left="0"
var indexs=0;
var nexts=0;
// console.log(h)
// t=setInterval(aar,3000)
function aar(){
nexts++
if (nexts==tupianbox.length) {
nexts=0
};
tupianbox[nexts].style.left=zw+"px"
animate(tupianbox[indexs],{left:-zw},500);
animate(tupianbox[nexts],{left:0},500)
indexs=nexts
}
// shishang5.onmouseover=function(){
// clearInterval(t);
// };
// shishang5.onmouseout=function(){
// t=setInterval(aar,3000)
// };
// 左右按钮
leftbtn[0].onclick=function(){
aar()
}
rightbtn[0].onclick=function(){
// clearInterval(t);
nexts--
if (nexts<0) {
nexts=tupianbox.length-1
};
tupianbox[nexts].style.left=-zw+"px"
animate(tupianbox[indexs],{left:zw},1000);
animate(tupianbox[nexts],{left:0},1000)
indexs=nexts;
}
}
// 按需加载
var youhua=$('.youhua');
var hs=document.documentElement.clientHeight;
var boximg=[];
var flags=[];
var fc=$('a',$('.fc')[0]);
var aa=true
for (var i = 0; i < youhua.length; i++) {
boximg.push(youhua[i].offsetTop);
flags.push(true);
};
window.onscroll=function(){
var top=document.body.scrollTop||document.documentElement.scrollTop;
// console.log(h)
for (var i = 0; i < boximg.length; i++) {
if(boximg[i]<=top+hs&&flags[i]){
flags[i]=false;
var imgs=$('img',youhua[i]);
for (var j = 0; j < imgs.length; j++) {
imgs[j].src=imgs[j].getAttribute('asrc')
};
}
};
//浮窗导航高光
// 浮窗导航
var fca=$('.fc')[0];
// var h=document.documentElement.clientHeight
// document.onscroll=function(){
// var Ih=document.body.scrollTop||document.documentElement.scrollTop;
if(top<1000&&aa){
aa=false;
// fca.style.display='none'
animate(fca,{bottom:-545},150)
// console.log(hs)
}
if(top>=1000&&aa==false){
aa=true;
// fca.style.display='block'
animate(fca,{bottom:(hs-545)/2},150)
};
}
//楼层跳转
// var youhuatop=
// console.log(top)
// for(var i=0;i<fc.length;i++){
// for(var j=0;j<youhua.length;j++){
// var youhuatop=youhua[0].offsetTop
// console.log(youhuatop)
// if(top>youhuatop){
// fc[j].className="youhua tianjialei"
// }
// }
}
// 头部隐藏卡片
var wx=$('.wx')[0];
var hy=$('.wx-erweima')[0]
yidong(wx)
var tp=$('.ks4a')[0]
var aa=$('a',tp)[0]
var b=tp.getElementsByTagName('b')[0];
yidong(wx,tp,hy,aa,b)
| var wxs=$('.shouji')[0];
var hys=$(".shoujji")[0]; | random_line_split | |
yintai.js | {index=0};
// 循环遍历
for (var i = 0; i < as.length; i++) {
// 先把所有照片层级调低，轮播点的颜色为空
as[i].style.zIndex=0;
bodiandiv[i].style.background='';
};
as[index].style.zIndex=10;
bodiandiv[index].style.background='#e5004f';
}
box[0].onmouseover=function(){
clearInterval(t);
lrclickbox.style.zIndex=15;
};
box[0].onmouseout=function(){
t=setInterval(move,2000);
lrclickbox.style.zIndex=0;
};
for (var i = 0; i < bodiandiv.length; i++) {
bodiandiv[i].index=i;
bodiandiv[i].onmouseover=function(){
for (var j = 0; j < as.length; j++) {
bodiandiv[j].style.background='';
as[j].style.zIndex=0;
}
as[this.index].style.zIndex=10;
bodiandiv[this.index].style.background='#e5004f';
}
};
rightclick[0].onclick=function(){
move();
};
rightclick[0].onmouseover=function(){
rightclick[0].style.background='#cc477a';
}
rightclick[0].onmouseout=function(){
rightclick[0].style.background='';
}
leftclick[0].onmouseover=function(){
leftclick[0].style.background='#cc477a';
}
leftclick[0].onmouseout=function(){
leftclick[0].style.background='';
}
leftclick[0].onclick=function(){
index--
if (index<0) {index=as.length-1};
for (var i = 0; i < as.length; i++) {
as[i].style.zIndex=0;
bodiandiv[i].style.background=""
};
as[index].style.zIndex=10;
bodiandiv[index].style.background="#e5004f"
}
// 选项卡开始
var xxk=getClass("link",document);
var inner=xxk[0].getElementsByTagName("a");
var hongdian=xxk[0].getElementsByTagName("span");
var shows=getClass("zw3",document);
for (var i = 0; i < inner.length; i++) {
inner[i].aa=i;
shows[0].style.display='block';
hongdian[0].style.display="block";
inner[0].style.borderBottom="4px solid red";
inner[i].onmouseover=function(){
for (var j = 0; j <shows.length; j++) {
shows[j].style.display='none';
inner[j].style.borderBottom="";
hongdian[j].style.display="none";
};
shows[this.aa].style.display='block';
this.style.borderBottom="4px solid red";
hongdian[this.aa].style.display="block";
};
};
// 图片四边的动画效果
var zw4s=getClass('zw4',document);
// paomaxian(zw4s[0])
// paomaxian(zw4s[1])
for (var i = 0; i < zw4s.length; i++) {
paomaxian(zw4s[i],220,263);
};
function paomaxian(zw4s,x,y){
var zuoshangs=getClass("zuoshang",zw4s);
var youxias=getClass("youxia",zw4s);
var shangzuos=getClass("shangzuo",zw4s);
var xiayous=getClass("xiayou",zw4s);
zw4s.onmouseover=function(){
animate(zuoshangs[0],{height:y},400);
animate(youxias[0],{height:y},400);
animate(shangzuos[0],{width:x},400);
animate(xiayous[0],{width:x},400);
}
zw4s.onmouseout=function(){
animate(zuoshangs[0],{height:0},400);
animate(youxias[0],{height:0},400);
animate(shangzuos[0],{width:0},400);
animate(xiayous[0],{width:0},400);
}
}
// 热门品牌动画
var zw4s=$('.zhengwen4')
for (var i = 0; i < zw4s.length; i++) {
paomaxian(zw4s[i],198,250)
};
// 时尚名品动画
var zw4s=$('.shishang8a');
for (var i = 0; i < zw4s.length; i++) {
paomaxian(zw4s[i],272,182)
};
// 热门品牌选项卡
var anniu=getClass('zhengwen3a',document);
var ab=anniu[0].getElementsByTagName('a');
var span1=anniu[0].getElementsByTagName('span');
var zhenwen=getClass('zhengwen4box',document);
for (var i = 0; i < ab.length; i++) {
ab[i].aa=i;
ab[0].style.borderBottom='3px solid red';
span1[0].style.display='block';
zhenwen[0].style.display='block';
ab[i].onmouseover=function(){
for (var j = 0; j < zhenwen.length; j++) {
ab[j].style.borderBottom='';
span1[j].style.display='none';
zhenwen[j].style.display='none';
};
span1[this.aa].style.display='block';
zhenwen[this.aa].style.display='block';
this.style.borderBottom='3px solid red';
};
};
// 时尚名品无缝轮播模式图模式
var box=$('.shishang7');
for(var i=0;i<box.length;i++){
fengzhuang(box[i])
}
function fengzhuang(box){
var n=0;
var next=0;
var boximg=$('.imgbox',box)[0]
var img=$("a",box);
img[0].style.left='0';
var anniu=$('.sh7a',box);
anniu[0].style.background='red';
var btn=$('.shanniu',box)[0];
var left=$('.shleft',btn);
var right=$('.shright',btn);
var iw=parseInt(getStyle(img[0],"width"));
//向左轮播
function lunbo(){
next=n+1;
if (next==img.length) {
return
};
for (var i = 0; i < img.length; i++) {
anniu[i].style.background=''
};
img[next].style.left=iw+'px';
animate(img[n],{left:-iw},700);
animate(img[next],{left:0},700);
anniu[n].style.background=""
anniu[next].style.background='red'
n=next;
};
//向右轮播
function fanxiang(){
next=n-1;
if (next<0) {
return;
};
for (var i = 0; i < img.length; i++) {
anniu[i].style.background=''
};
img[next].style.left=-iw+'px';
animate(img[n],{left:iw},700);
animate(img[next],{left:0},700);
anniu[n].style.background=""
anniu[next].style.background='red'
n=next;
}
anniu[0].onmouseover=function(){
fanxiang();
};
anniu[1].onmouseover=function(){
lunbo();
}
box.onmouseover=function(){
btn.style.display="block"
box.style.opacity='0.8';
}
box.onmouseout=function(){
btn.style.display="none"
box.style.opacity='1';
}
btn.onmousedown=function(){
return false;
}
right[0].onclick=function(){
lunbo();
}
left[0].onclick=function(){
fanxiang();
}
// 无缝轮播
var shishang5=$('.shishang5')
for (var i = 0; i < shishang5.length; i++) {
diaoyong(shishang5[i])
};
function diaoyong(shishang5){
var tupianbox=$('.shishang6',shishang5);
// alert(tupianbox.length)
var | th) | identifier_name | |
yintai.js | };
// 时尚名品无缝轮播模式图模式
var box=$('.shishang7');
for(var i=0;i<box.length;i++){
fengzhuang(box[i])
}
function fengzhuang(box){
var n=0;
var next=0;
var boximg=$('.imgbox',box)[0]
var img=$("a",box);
img[0].style.left='0';
var anniu=$('.sh7a',box);
anniu[0].style.background='red';
var btn=$('.shanniu',box)[0];
var left=$('.shleft',btn);
var right=$('.shright',btn);
var iw=parseInt(getStyle(img[0],"width"));
//向左轮播
function lunbo(){
next=n+1;
if (next==img.length) {
return
};
for (var i = 0; i < img.length; i++) {
anniu[i].style.background=''
};
img[next].style.left=iw+'px';
animate(img[n],{left:-iw},700);
animate(img[next],{left:0},700);
anniu[n].style.background=""
anniu[next].style.background='red'
n=next;
};
//向右轮播
function fanxiang(){
next=n-1;
if (next<0) {
return;
};
for (var i = 0; i < img.length; i++) {
anniu[i].style.background=''
};
img[next].style.left=-iw+'px';
animate(img[n],{left:iw},700);
animate(img[next],{left:0},700);
anniu[n].style.background=""
anniu[next].style.background='red'
n=next;
}
anniu[0].onmouseover=function(){
fanxiang();
};
anniu[1].onmouseover=function(){
lunbo();
}
box.onmouseover=function(){
btn.style.display="block"
box.style.opacity='0.8';
}
box.onmouseout=function(){
btn.style.display="none"
box.style.opacity='1';
}
btn.onmousedown=function(){
return false;
}
right[0].onclick=function(){
lunbo();
}
left[0].onclick=function(){
fanxiang();
}
// 无缝轮播
var shishang5=$('.shishang5')
for (var i = 0; i < shishang5.length; i++) {
diaoyong(shishang5[i])
};
function diaoyong(shishang5){
var tupianbox=$('.shishang6',shishang5);
// alert(tupianbox.length)
var leftbtn=$('.shishang6b',shishang5);
var rightbtn=$('.shishang6c',shishang5);
var h=document.documentElement.clientHeight;
var zw=tupianbox[0].offsetWidth;
tupianbox[0].style.left="0"
var indexs=0;
var nexts=0;
// console.log(h)
// t=setInterval(aar,3000)
function aar(){
nexts++
if (nexts==tupianbox.length) {
nexts=0
};
tupianbox[nexts].style.left=zw+"px"
animate(tupianbox[indexs],{left:-zw},500);
animate(tupianbox[nexts],{left:0},500)
indexs=nexts
}
// shishang5.onmouseover=function(){
// clearInterval(t);
// };
// shishang5.onmouseout=function(){
// t=setInterval(aar,3000)
// };
// 左右按钮
leftbtn[0].onclick=function(){
aar()
}
rightbtn[0].onclick=function(){
// clearInterval(t);
nexts--
if (nexts<0) {
nexts=tupianbox.length-1
};
tupianbox[nexts].style.left=-zw+"px"
animate(tupianbox[indexs],{left:zw},1000);
animate(tupianbox[nexts],{left:0},1000)
indexs=nexts;
}
}
// 按需加载
var youhua=$('.youhua');
var hs=document.documentElement.clientHeight;
var boximg=[];
var flags=[];
var fc=$('a',$('.fc')[0]);
var aa=true
for (var i = 0; i < youhua.length; i++) {
boximg.push(youhua[i].offsetTop);
flags.push(true);
};
window.onscroll=function(){
var top=document.body.scrollTop||document.documentElement.scrollTop;
// console.log(h)
for (var i = 0; i < boximg.length; i++) {
if(boximg[i]<=top+hs&&flags[i]){
flags[i]=false;
var imgs=$('img',youhua[i]);
for (var j = 0; j < imgs.length; j++) {
imgs[j].src=imgs[j].getAttribute('asrc')
};
}
};
//浮窗导航高光
// 浮窗导航
var fca=$('.fc')[0];
// var h=document.documentElement.clientHeight
// document.onscroll=function(){
// var Ih=document.body.scrollTop||document.documentElement.scrollTop;
if(top<1000&&aa){
aa=false;
// fca.style.display='none'
animate(fca,{bottom:-545},150)
// console.log(hs)
}
if(top>=1000&&aa==false){
aa=true;
// fca.style.display='block'
animate(fca,{bottom:(hs-545)/2},150)
};
}
//楼层跳转
// var youhuatop=
// console.log(top)
// for(var i=0;i<fc.length;i++){
// for(var j=0;j<youhua.length;j++){
// var youhuatop=youhua[0].offsetTop
// console.log(youhuatop)
// if(top>youhuatop){
// fc[j].className="youhua tianjialei"
// }
// }
}
// 头部隐藏卡片
var wx=$('.wx')[0];
var hy=$('.wx-erweima')[0]
yidong(wx)
var tp=$('.ks4a')[0]
var aa=$('a',tp)[0]
var b=tp.getElementsByTagName('b')[0];
yidong(wx,tp,hy,aa,b)
var wxs=$('.shouji')[0];
var hys=$(".shoujji")[0];
var tps=$(".weixin")[0];
var aas=$("a",tps)[0];
var bs=$("b",tps)[0];
yidong(wxs,tps,hys,aas,bs);
var kst=$(".ks3t")[0];
var ks=$(".ks33")[0];
var aar=$("a",ks)[0];
var ksb=$(".ks3b")[0];
var bb=$("b",ks)[0];
yidong(kst,ks,ksb,aar,bb);
function yidong(wx,tp,hy,aa,b){
hover(wx,function(){
tp.style.background="#fff"
hy.style.display="block"
aa.style.color="red"
b.style.background=" url(jpg/tubiao05.jpg) 0 -17px no-repeat"
},function(){
tp.style.background=""
hy.style.display="none"
aa.style.color=""
b.style.background=""
})
}
// banner右边详情页
var furongqi=$(".banner1c");
for (var i = 0; i < furongqi.length; i++) {cedao(furongqi[i])
// console.log(furongqi[i])
};
function cedao(sd){
var bosxq=$(".xiangqin",sd)[0];
hover(sd,function(){
bosxq.style.display='block';
},function(){
bosxq.style.display='none';
})
}
// banner上的右侧图标动画
var boxs=$(".banner1a")[0];
var imgy=$("img",boxs)[0];
imgy.onmouseover=function(){
animate(imgy,{left:583},300)
}
imgy.onmouseout=function(){
animate(imgy,{left:590},300)
}
// | 页脚的三个标志
var yj=$(".yj")[0];
var yjimg=$("a",yj);
for (var i = 0; i < yjimg.length; i++) {
yejiao(yjimg[i])
};
function yejiao(aa){
hover( | identifier_body | |
yintai.js | as[j].style.zIndex=0;
}
as[this.index].style.zIndex=10;
bodiandiv[this.index].style.background='#e5004f';
| 0].onmouseover=function(){
rightclick[0].style.background='#cc477a';
}
rightclick[0].onmouseout=function(){
rightclick[0].style.background='';
}
leftclick[0].onmouseover=function(){
leftclick[0].style.background='#cc477a';
}
leftclick[0].onmouseout=function(){
leftclick[0].style.background='';
}
leftclick[0].onclick=function(){
index--
if (index<0) {index=as.length-1};
for (var i = 0; i < as.length; i++) {
as[i].style.zIndex=0;
bodiandiv[i].style.background=""
};
as[index].style.zIndex=10;
bodiandiv[index].style.background="#e5004f"
}
// 选项卡开始
var xxk=getClass("link",document);
var inner=xxk[0].getElementsByTagName("a");
var hongdian=xxk[0].getElementsByTagName("span");
var shows=getClass("zw3",document);
for (var i = 0; i < inner.length; i++) {
inner[i].aa=i;
shows[0].style.display='block';
hongdian[0].style.display="block";
inner[0].style.borderBottom="4px solid red";
inner[i].onmouseover=function(){
for (var j = 0; j <shows.length; j++) {
shows[j].style.display='none';
inner[j].style.borderBottom="";
hongdian[j].style.display="none";
};
shows[this.aa].style.display='block';
this.style.borderBottom="4px solid red";
hongdian[this.aa].style.display="block";
};
};
// 图片四边的动画效果
var zw4s=getClass('zw4',document);
// paomaxian(zw4s[0])
// paomaxian(zw4s[1])
for (var i = 0; i < zw4s.length; i++) {
paomaxian(zw4s[i],220,263);
};
function paomaxian(zw4s,x,y){
var zuoshangs=getClass("zuoshang",zw4s);
var youxias=getClass("youxia",zw4s);
var shangzuos=getClass("shangzuo",zw4s);
var xiayous=getClass("xiayou",zw4s);
zw4s.onmouseover=function(){
animate(zuoshangs[0],{height:y},400);
animate(youxias[0],{height:y},400);
animate(shangzuos[0],{width:x},400);
animate(xiayous[0],{width:x},400);
}
zw4s.onmouseout=function(){
animate(zuoshangs[0],{height:0},400);
animate(youxias[0],{height:0},400);
animate(shangzuos[0],{width:0},400);
animate(xiayous[0],{width:0},400);
}
}
// 热门品牌动画
var zw4s=$('.zhengwen4')
for (var i = 0; i < zw4s.length; i++) {
paomaxian(zw4s[i],198,250)
};
// 时尚名品动画
var zw4s=$('.shishang8a');
for (var i = 0; i < zw4s.length; i++) {
paomaxian(zw4s[i],272,182)
};
// 热门品牌选项卡
var anniu=getClass('zhengwen3a',document);
var ab=anniu[0].getElementsByTagName('a');
var span1=anniu[0].getElementsByTagName('span');
var zhenwen=getClass('zhengwen4box',document);
for (var i = 0; i < ab.length; i++) {
ab[i].aa=i;
ab[0].style.borderBottom='3px solid red';
span1[0].style.display='block';
zhenwen[0].style.display='block';
ab[i].onmouseover=function(){
for (var j = 0; j < zhenwen.length; j++) {
ab[j].style.borderBottom='';
span1[j].style.display='none';
zhenwen[j].style.display='none';
};
span1[this.aa].style.display='block';
zhenwen[this.aa].style.display='block';
this.style.borderBottom='3px solid red';
};
};
// 时尚名品无缝轮播模式图模式
var box=$('.shishang7');
for(var i=0;i<box.length;i++){
fengzhuang(box[i])
}
function fengzhuang(box){
var n=0;
var next=0;
var boximg=$('.imgbox',box)[0]
var img=$("a",box);
img[0].style.left='0';
var anniu=$('.sh7a',box);
anniu[0].style.background='red';
var btn=$('.shanniu',box)[0];
var left=$('.shleft',btn);
var right=$('.shright',btn);
var iw=parseInt(getStyle(img[0],"width"));
//向左轮播
function lunbo(){
next=n+1;
if (next==img.length) {
return
};
for (var i = 0; i < img.length; i++) {
anniu[i].style.background=''
};
img[next].style.left=iw+'px';
animate(img[n],{left:-iw},700);
animate(img[next],{left:0},700);
anniu[n].style.background=""
anniu[next].style.background='red'
n=next;
};
//向右轮播
function fanxiang(){
next=n-1;
if (next<0) {
return;
};
for (var i = 0; i < img.length; i++) {
anniu[i].style.background=''
};
img[next].style.left=-iw+'px';
animate(img[n],{left:iw},700);
animate(img[next],{left:0},700);
anniu[n].style.background=""
anniu[next].style.background='red'
n=next;
}
anniu[0].onmouseover=function(){
fanxiang();
};
anniu[1].onmouseover=function(){
lunbo();
}
box.onmouseover=function(){
btn.style.display="block"
box.style.opacity='0.8';
}
box.onmouseout=function(){
btn.style.display="none"
box.style.opacity='1';
}
btn.onmousedown=function(){
return false;
}
right[0].onclick=function(){
lunbo();
}
left[0].onclick=function(){
fanxiang();
}
// 无缝轮播
var shishang5=$('.shishang5')
for (var i = 0; i < shishang5.length; i++) {
diaoyong(shishang5[i])
};
function diaoyong(shishang5){
var tupianbox=$('.shishang6',shishang5);
// alert(tupianbox.length)
var leftbtn=$('.shishang6b',shishang5);
var rightbtn=$('.shishang6c',shishang5);
var h=document.documentElement.clientHeight;
var zw=tupianbox[0].offsetWidth;
tupianbox[0].style.left="0"
var indexs=0;
var nexts=0;
// console.log(h)
// t=setInterval(aar,3000)
function aar(){
nexts++
if (nexts==tupianbox.length) {
nexts=0
};
tupianbox[nexts].style.left=zw+"px"
animate(tupianbox[indexs],{left:-zw},500);
animate(tupianbox[nexts],{left:0},500)
indexs=nexts
}
// shishang5.onmouseover=function(){
// clearInterval(t);
// };
// shishang5.onmouseout=function(){
// t=setInterval(aar,3000)
// };
// 左右按钮 | }
};
rightclick[0].onclick=function(){
move();
};
rightclick[ | conditional_block |
manager.py | :`~budget.Note` :class:`~pandas.Series` using a connection to a SQL database using
Parameters
----------
con : SQLAlchemy connectable, :class:`str`, or :mod:`sqlite3` connection
SQL connection
Returns
-------
:class:`~pandas.Series`
"""
# Read the whole table of notes
notes = pd.read_sql_query(sql=f'select * from {self.SQL_NOTE_TABLE}', con=con)
self.logger.debug(f'{notes.shape[0]} notes loaded from \'{self.SQL_NOTE_TABLE}\'')
# Set up the index, which will be the ID of the transaction the note is attached to
notes.set_index(notes.columns[0], inplace=True)
try:
# Select only the first column (should only be one)
notes = notes.iloc[:, 0].map(NoteManager.eval_note)
except NameError:
self.logger.debug('No notes loaded')
pass
# Assign to attribute
self.notes = notes
return notes
@staticmethod
def eval_note(input: str) -> note.Note:
"""Evaluates the :func:`repr` string, which reconstructs a :class:`~budget.Note` object
Parameters
----------
input : :class:`str`
:class:`str` produced by the :func:`repr` of that object
Returns
-------
:class:`~budget.Note`
"""
try:
return eval(input)
except (NameError, SyntaxError):
m = NOTE_PARSE_REGEX.search(input)
return NoteManager.parse_note(m.group(1), m.group(2))
@staticmethod
def parse_note(id: str, input: str, add_note_types=None) -> note.Note:
"""Looks for the `tag` of each type of :class:`~budget.Note` in the `input` string, then constructs a new
:class:`~budget.Note` object when it finds one
Parameters
----------
id : :class:`str`
id of the `Note` to create
input : :class:`str`
input :class:`str` to look in
add_note_types :
additional :class:`~budget.Note` types to parse
Returns
-------
:class:`~budget.Note`
"""
note_types = [SplitNote, Link, Category]
if add_note_types is not None:
try:
note_types.append(add_note_types)
except:
note_types.extend(add_note_types)
if isinstance(input, str):
for nt in note_types:
try:
if nt._tag in input:
res = nt(id, input)
break
except AttributeError:
raise AttributeError('Notes must have a _tag attribute')
try:
return res
except NameError as e:
# res won't be set if none of the tags match
return Note(id, input)
else:
if isinstance(input, Note):
raise TypeError(f'\'{input}\' is already a {type(input)}')
else:
raise TypeError(f'unknown type of note: {type(input)}')
def validate_notes(self, ids: pd.Series) -> bool:
"""Checks to make sure that all of the :class:`~budget.Note`s are contained in the ids
Parameters
----------
ids : set or like-like
:class:`list` or something that can be used in :meth:`~pandas.Series.isin`
Returns
-------
bool
`True` if all of the `Notes` in the :class:`~budget.notes.NoteManager` are in the given list of IDs
"""
return self.notes.map(lambda n: n.id).isin(ids).all()
def | (self, id: str, note: str, drop_dups: bool = True):
"""Parses a string into a :class:`~budget.Note` object and adds it to the :class:`~budget.notes.NoteManager` using
:class:`~pandas.Series.append` and optionally uses :class:`~pandas.Series.drop_duplicates`
Parameters
----------
id : str
id of the transaction to attach the :class:`~budget.Note` to
note : str
input string used to create the :class:`~budget.Note` object
drop_dups : bool
Whether to drop the duplicate notes
"""
n = self.parse_note(id, note)
self.notes = self.notes.append([pd.Series([n], index=[n.id])])
if drop_dups:
self.drop_duplicates()
def drop(self, id: str, note_text: str):
"""Drops a specific :class:`~budget.Note` using its ID and text
Parameters
----------
id : str
id of the note to drop
note_text : str
text of the note to drop
"""
print(f'Dropping note from {id}: {note_text}')
self.notes = self.notes[~self.notes.apply(
lambda n: (n.note == note_text) and (n.id == id)
)]
def drop_duplicates(self):
"""Removes duplicate `Notes` in the :class:`~budget.notes.NoteManager`
"""
self.notes = self.notes[~self.notes.map(repr).duplicated()]
def save_notes(self, con):
self.notes.map(repr).to_sql(name=self.SQL_NOTE_TABLE, con=con, if_exists='replace')
def get_notes_by_id(self, ids: List[str]) -> pd.Series:
"""Gets the notes that match the IDs in the given list
Parameters
----------
ids : List[str]
list of ids to get the notes
Returns
-------
:class:`~pandas.Series`
"""
return self.notes[self.notes.apply(lambda n: n.id in ids)]
def get_notes_by_type(self, typ: type) -> pd.Series:
"""Gets the notes that match the given type
Parameters
----------
typ : type
type of :class:`~budget.Note` to get
Returns
-------
:class:`~pandas.Series`
"""
# doesn't use isinstance() to prevent subtypes from being selected
return self.notes[self.notes.apply(lambda n: type(n) is typ)]
def manual_ids(self, cat: str) -> np.ndarray:
"""Gets ids of transactions that have been manually categorized as the given category
Parameters
----------
cat : str
category of transactions to get IDs for
Returns
-------
:class:`~numpy.ndarray`
"""
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a Category type and have a matching categorization
lambda n: isinstance(n, note.Category) and n.category == cat
)
].apply(lambda n: n.id).values
def split_ids(self, cat: str) -> pd.Series:
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a SplitNote type and have the category in one of its parts
lambda n: isinstance(n, split.SplitNote) and cat in n.parts
)
# convert to the value of the id attribute of each note
].apply(lambda n: n.id)
def linked_ids(self, df: pd.DataFrame) -> np.ndarray:
"""Gets ids of transactions that target those in the given DataFrame
Example
Transactions A and B are both linked to transaction C, which appears in the given DataFrame
Returns a Series of ids that include the ids of A and B
Returns
-------
:class:`~numpy.ndarray`: str
"""
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a Link type and have a target id in the given DataFrame
lambda n: isinstance(n, note.Link) and n.target in df['id'].values
)
# convert to the value of the id attribute of each note
].apply(lambda n: n.id).values
def apply_linked(self, df: pd.DataFrame) -> pd.DataFrame:
"""Applies Link notes in the given DataFrame, adding the value of each linked transaction onto the one it targets
The DataFrame needs to include both the original transactions and the ones linked to them. The values of the linked
transactions will be set to 0 as they are added onto the target transaction
Parameters
----------
df : :class:`~pandas.DataFrame`
transactions to apply the linked notes to
Returns
-------
:class:`~pandas.DataFrame`
:class:`~pandas.DataFrame` of the modified transactions
"""
link_notes = self.get_notes_by_type(note.Link)
source_in_df = link_notes.apply(lambda n: n.id in df['id'].values)
target_in_df = link_notes.apply(lambda n: n.target in df['id'].values)
# assert (target_in_df & ~source_in_df).any()
df = df.reset_index().set_index('id')
try:
# if both source and target exist in the DataFrame, add the source Amount to the target Amount
for n in link_notes[source_in_df & target_in_df]:
df.loc[n.target, 'Amount'] += df.loc[n.id, 'Amount']
# set the values of all source transactions to 0
for n in link_notes[source_in_df]:
df.loc[n.id, 'Amount'] = 0
except Exception as e:
raise
df = df.reset_index().set_index(df.columns[0])
return df
def apply_split(self | add_note | identifier_name |
manager.py | :`~budget.Note` :class:`~pandas.Series` using a connection to a SQL database using
Parameters
----------
con : SQLAlchemy connectable, :class:`str`, or :mod:`sqlite3` connection
SQL connection
Returns
-------
:class:`~pandas.Series`
"""
# Read the whole table of notes
notes = pd.read_sql_query(sql=f'select * from {self.SQL_NOTE_TABLE}', con=con)
self.logger.debug(f'{notes.shape[0]} notes loaded from \'{self.SQL_NOTE_TABLE}\'')
# Set up the index, which will be the ID of the transaction the note is attached to
notes.set_index(notes.columns[0], inplace=True)
try:
# Select only the first column (should only be one)
notes = notes.iloc[:, 0].map(NoteManager.eval_note)
except NameError:
self.logger.debug('No notes loaded')
pass
# Assign to attribute
self.notes = notes
return notes
@staticmethod
def eval_note(input: str) -> note.Note:
"""Evaluates the :func:`repr` string, which reconstructs a :class:`~budget.Note` object
Parameters
----------
input : :class:`str`
:class:`str` produced by the :func:`repr` of that object
Returns
-------
:class:`~budget.Note`
"""
try:
return eval(input)
except (NameError, SyntaxError):
m = NOTE_PARSE_REGEX.search(input)
return NoteManager.parse_note(m.group(1), m.group(2))
@staticmethod
def parse_note(id: str, input: str, add_note_types=None) -> note.Note:
"""Looks for the `tag` of each type of :class:`~budget.Note` in the `input` string, then constructs a new
:class:`~budget.Note` object when it finds one
Parameters
----------
id : :class:`str`
id of the `Note` to create
input : :class:`str`
input :class:`str` to look in
add_note_types :
additional :class:`~budget.Note` types to parse
Returns
-------
:class:`~budget.Note`
"""
note_types = [SplitNote, Link, Category]
if add_note_types is not None:
|
if isinstance(input, str):
for nt in note_types:
try:
if nt._tag in input:
res = nt(id, input)
break
except AttributeError:
raise AttributeError('Notes must have a _tag attribute')
try:
return res
except NameError as e:
# res won't be set if none of the tags match
return Note(id, input)
else:
if isinstance(input, Note):
raise TypeError(f'\'{input}\' is already a {type(input)}')
else:
raise TypeError(f'unknown type of note: {type(input)}')
def validate_notes(self, ids: pd.Series) -> bool:
"""Checks to make sure that all of the :class:`~budget.Note`s are contained in the ids
Parameters
----------
ids : set or like-like
:class:`list` or something that can be used in :meth:`~pandas.Series.isin`
Returns
-------
bool
`True` if all of the `Notes` in the :class:`~budget.notes.NoteManager` are in the given list of IDs
"""
return self.notes.map(lambda n: n.id).isin(ids).all()
def add_note(self, id: str, note: str, drop_dups: bool = True):
"""Parses a string into a :class:`~budget.Note` object and adds it to the :class:`~budget.notes.NoteManager` using
:class:`~pandas.Series.append` and optionally uses :class:`~pandas.Series.drop_duplicates`
Parameters
----------
id : str
id of the transaction to attach the :class:`~budget.Note` to
note : str
input string used to create the :class:`~budget.Note` object
drop_dups : bool
Whether to drop the duplicate notes
"""
n = self.parse_note(id, note)
self.notes = self.notes.append([pd.Series([n], index=[n.id])])
if drop_dups:
self.drop_duplicates()
def drop(self, id: str, note_text: str):
"""Drops a specific :class:`~budget.Note` using its ID and text
Parameters
----------
id : str
id of the note to drop
note_text : str
text of the note to drop
"""
print(f'Dropping note from {id}: {note_text}')
self.notes = self.notes[~self.notes.apply(
lambda n: (n.note == note_text) and (n.id == id)
)]
def drop_duplicates(self):
"""Removes duplicate `Notes` in the :class:`~budget.notes.NoteManager`
"""
self.notes = self.notes[~self.notes.map(repr).duplicated()]
def save_notes(self, con):
self.notes.map(repr).to_sql(name=self.SQL_NOTE_TABLE, con=con, if_exists='replace')
def get_notes_by_id(self, ids: List[str]) -> pd.Series:
"""Gets the notes that match the IDs in the given list
Parameters
----------
ids : List[str]
list of ids to get the notes
Returns
-------
:class:`~pandas.Series`
"""
return self.notes[self.notes.apply(lambda n: n.id in ids)]
def get_notes_by_type(self, typ: type) -> pd.Series:
"""Gets the notes that match the given type
Parameters
----------
typ : type
type of :class:`~budget.Note` to get
Returns
-------
:class:`~pandas.Series`
"""
# doesn't use isinstance() to prevent subtypes from being selected
return self.notes[self.notes.apply(lambda n: type(n) is typ)]
def manual_ids(self, cat: str) -> np.ndarray:
"""Gets ids of transactions that have been manually categorized as the given category
Parameters
----------
cat : str
category of transactions to get IDs for
Returns
-------
:class:`~numpy.ndarray`
"""
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a Category type and have a matching categorization
lambda n: isinstance(n, note.Category) and n.category == cat
)
].apply(lambda n: n.id).values
def split_ids(self, cat: str) -> pd.Series:
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a SplitNote type and have the category in one of its parts
lambda n: isinstance(n, split.SplitNote) and cat in n.parts
)
# convert to the value of the id attribute of each note
].apply(lambda n: n.id)
def linked_ids(self, df: pd.DataFrame) -> np.ndarray:
"""Gets ids of transactions that target those in the given DataFrame
Example
Transactions A and B are both linked to transaction C, which appears in the given DataFrame
Returns a Series of ids that include the ids of A and B
Returns
-------
:class:`~numpy.ndarray`: str
"""
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a Link type and have a target id in the given DataFrame
lambda n: isinstance(n, note.Link) and n.target in df['id'].values
)
# convert to the value of the id attribute of each note
].apply(lambda n: n.id).values
def apply_linked(self, df: pd.DataFrame) -> pd.DataFrame:
"""Applies Link notes in the given DataFrame, adding the value of each linked transaction onto the one it targets
The DataFrame needs to include both the original transactions and the ones linked to them. The values of the linked
transactions will be set to 0 as they are added onto the target transaction
Parameters
----------
df : :class:`~pandas.DataFrame`
transactions to apply the linked notes to
Returns
-------
:class:`~pandas.DataFrame`
:class:`~pandas.DataFrame` of the modified transactions
"""
link_notes = self.get_notes_by_type(note.Link)
source_in_df = link_notes.apply(lambda n: n.id in df['id'].values)
target_in_df = link_notes.apply(lambda n: n.target in df['id'].values)
# assert (target_in_df & ~source_in_df).any()
df = df.reset_index().set_index('id')
try:
# if both source and target exist in the DataFrame, add the source Amount to the target Amount
for n in link_notes[source_in_df & target_in_df]:
df.loc[n.target, 'Amount'] += df.loc[n.id, 'Amount']
# set the values of all source transactions to 0
for n in link_notes[source_in_df]:
df.loc[n.id, 'Amount'] = 0
except Exception as e:
raise
df = df.reset_index().set_index(df.columns[0])
return df
def apply_split(self | try:
note_types.append(add_note_types)
except:
note_types.extend(add_note_types) | conditional_block |
manager.py | :`~budget.Note` :class:`~pandas.Series` using a connection to a SQL database using
Parameters
----------
con : SQLAlchemy connectable, :class:`str`, or :mod:`sqlite3` connection
SQL connection
Returns
-------
:class:`~pandas.Series`
"""
# Read the whole table of notes
notes = pd.read_sql_query(sql=f'select * from {self.SQL_NOTE_TABLE}', con=con)
self.logger.debug(f'{notes.shape[0]} notes loaded from \'{self.SQL_NOTE_TABLE}\'')
# Set up the index, which will be the ID of the transaction the note is attached to
notes.set_index(notes.columns[0], inplace=True)
try:
# Select only the first column (should only be one)
notes = notes.iloc[:, 0].map(NoteManager.eval_note)
except NameError:
self.logger.debug('No notes loaded')
pass
# Assign to attribute
self.notes = notes
return notes
@staticmethod
def eval_note(input: str) -> note.Note:
"""Evaluates the :func:`repr` string, which reconstructs a :class:`~budget.Note` object
Parameters
----------
input : :class:`str`
:class:`str` produced by the :func:`repr` of that object
Returns
-------
:class:`~budget.Note`
"""
try:
return eval(input)
except (NameError, SyntaxError):
m = NOTE_PARSE_REGEX.search(input)
return NoteManager.parse_note(m.group(1), m.group(2))
@staticmethod
def parse_note(id: str, input: str, add_note_types=None) -> note.Note:
"""Looks for the `tag` of each type of :class:`~budget.Note` in the `input` string, then constructs a new
:class:`~budget.Note` object when it finds one
Parameters
----------
id : :class:`str`
id of the `Note` to create
input : :class:`str`
input :class:`str` to look in
add_note_types :
additional :class:`~budget.Note` types to parse
Returns
-------
:class:`~budget.Note`
"""
note_types = [SplitNote, Link, Category]
if add_note_types is not None:
try:
note_types.append(add_note_types)
except:
note_types.extend(add_note_types)
if isinstance(input, str):
for nt in note_types:
try:
if nt._tag in input:
res = nt(id, input)
break
except AttributeError:
raise AttributeError('Notes must have a _tag attribute')
try:
return res
except NameError as e:
# res won't be set if none of the tags match
return Note(id, input)
else:
if isinstance(input, Note):
raise TypeError(f'\'{input}\' is already a {type(input)}')
else: | def validate_notes(self, ids: pd.Series) -> bool:
"""Checks to make sure that all of the :class:`~budget.Note`s are contained in the ids
Parameters
----------
ids : set or like-like
:class:`list` or something that can be used in :meth:`~pandas.Series.isin`
Returns
-------
bool
`True` if all of the `Notes` in the :class:`~budget.notes.NoteManager` are in the given list of IDs
"""
return self.notes.map(lambda n: n.id).isin(ids).all()
def add_note(self, id: str, note: str, drop_dups: bool = True):
"""Parses a string into a :class:`~budget.Note` object and adds it to the :class:`~budget.notes.NoteManager` using
:class:`~pandas.Series.append` and optionally uses :class:`~pandas.Series.drop_duplicates`
Parameters
----------
id : str
id of the transaction to attach the :class:`~budget.Note` to
note : str
input string used to create the :class:`~budget.Note` object
drop_dups : bool
Whether to drop the duplicate notes
"""
n = self.parse_note(id, note)
self.notes = self.notes.append([pd.Series([n], index=[n.id])])
if drop_dups:
self.drop_duplicates()
def drop(self, id: str, note_text: str):
"""Drops a specific :class:`~budget.Note` using its ID and text
Parameters
----------
id : str
id of the note to drop
note_text : str
text of the note to drop
"""
print(f'Dropping note from {id}: {note_text}')
self.notes = self.notes[~self.notes.apply(
lambda n: (n.note == note_text) and (n.id == id)
)]
def drop_duplicates(self):
"""Removes duplicate `Notes` in the :class:`~budget.notes.NoteManager`
"""
self.notes = self.notes[~self.notes.map(repr).duplicated()]
def save_notes(self, con):
self.notes.map(repr).to_sql(name=self.SQL_NOTE_TABLE, con=con, if_exists='replace')
def get_notes_by_id(self, ids: List[str]) -> pd.Series:
"""Gets the notes that match the IDs in the given list
Parameters
----------
ids : List[str]
list of ids to get the notes
Returns
-------
:class:`~pandas.Series`
"""
return self.notes[self.notes.apply(lambda n: n.id in ids)]
def get_notes_by_type(self, typ: type) -> pd.Series:
"""Gets the notes that match the given type
Parameters
----------
typ : type
type of :class:`~budget.Note` to get
Returns
-------
:class:`~pandas.Series`
"""
# doesn't use isinstance() to prevent subtypes from being selected
return self.notes[self.notes.apply(lambda n: type(n) is typ)]
def manual_ids(self, cat: str) -> np.ndarray:
"""Gets ids of transactions that have been manually categorized as the given category
Parameters
----------
cat : str
category of transactions to get IDs for
Returns
-------
:class:`~numpy.ndarray`
"""
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a Category type and have a matching categorization
lambda n: isinstance(n, note.Category) and n.category == cat
)
].apply(lambda n: n.id).values
def split_ids(self, cat: str) -> pd.Series:
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a SplitNote type and have the category in one of its parts
lambda n: isinstance(n, split.SplitNote) and cat in n.parts
)
# convert to the value of the id attribute of each note
].apply(lambda n: n.id)
def linked_ids(self, df: pd.DataFrame) -> np.ndarray:
"""Gets ids of transactions that target those in the given DataFrame
Example
Transactions A and B are both linked to transaction C, which appears in the given DataFrame
Returns a Series of ids that include the ids of A and B
Returns
-------
:class:`~numpy.ndarray`: str
"""
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a Link type and have a target id in the given DataFrame
lambda n: isinstance(n, note.Link) and n.target in df['id'].values
)
# convert to the value of the id attribute of each note
].apply(lambda n: n.id).values
def apply_linked(self, df: pd.DataFrame) -> pd.DataFrame:
"""Applies Link notes in the given DataFrame, adding the value of each linked transaction onto the one it targets
The DataFrame needs to include both the original transactions and the ones linked to them. The values of the linked
transactions will be set to 0 as they are added onto the target transaction
Parameters
----------
df : :class:`~pandas.DataFrame`
transactions to apply the linked notes to
Returns
-------
:class:`~pandas.DataFrame`
:class:`~pandas.DataFrame` of the modified transactions
"""
link_notes = self.get_notes_by_type(note.Link)
source_in_df = link_notes.apply(lambda n: n.id in df['id'].values)
target_in_df = link_notes.apply(lambda n: n.target in df['id'].values)
# assert (target_in_df & ~source_in_df).any()
df = df.reset_index().set_index('id')
try:
# if both source and target exist in the DataFrame, add the source Amount to the target Amount
for n in link_notes[source_in_df & target_in_df]:
df.loc[n.target, 'Amount'] += df.loc[n.id, 'Amount']
# set the values of all source transactions to 0
for n in link_notes[source_in_df]:
df.loc[n.id, 'Amount'] = 0
except Exception as e:
raise
df = df.reset_index().set_index(df.columns[0])
return df
def apply_split(self, | raise TypeError(f'unknown type of note: {type(input)}')
| random_line_split |
manager.py | Parameters
----------
con : SQLAlchemy connectable, :class:`str`, or :mod:`sqlite3` connection
SQL connection
Returns
-------
:class:`~pandas.Series`
"""
# Read the whole table of notes
notes = pd.read_sql_query(sql=f'select * from {self.SQL_NOTE_TABLE}', con=con)
self.logger.debug(f'{notes.shape[0]} notes loaded from \'{self.SQL_NOTE_TABLE}\'')
# Set up the index, which will be the ID of the transaction the note is attached to
notes.set_index(notes.columns[0], inplace=True)
try:
# Select only the first column (should only be one)
notes = notes.iloc[:, 0].map(NoteManager.eval_note)
except NameError:
self.logger.debug('No notes loaded')
pass
# Assign to attribute
self.notes = notes
return notes
@staticmethod
def eval_note(input: str) -> note.Note:
"""Evaluates the :func:`repr` string, which reconstructs a :class:`~budget.Note` object
Parameters
----------
input : :class:`str`
:class:`str` produced by the :func:`repr` of that object
Returns
-------
:class:`~budget.Note`
"""
try:
return eval(input)
except (NameError, SyntaxError):
m = NOTE_PARSE_REGEX.search(input)
return NoteManager.parse_note(m.group(1), m.group(2))
@staticmethod
def parse_note(id: str, input: str, add_note_types=None) -> note.Note:
"""Looks for the `tag` of each type of :class:`~budget.Note` in the `input` string, then constructs a new
:class:`~budget.Note` object when it finds one
Parameters
----------
id : :class:`str`
id of the `Note` to create
input : :class:`str`
input :class:`str` to look in
add_note_types :
additional :class:`~budget.Note` types to parse
Returns
-------
:class:`~budget.Note`
"""
note_types = [SplitNote, Link, Category]
if add_note_types is not None:
try:
note_types.append(add_note_types)
except:
note_types.extend(add_note_types)
if isinstance(input, str):
for nt in note_types:
try:
if nt._tag in input:
res = nt(id, input)
break
except AttributeError:
raise AttributeError('Notes must have a _tag attribute')
try:
return res
except NameError as e:
# res won't be set if none of the tags match
return Note(id, input)
else:
if isinstance(input, Note):
raise TypeError(f'\'{input}\' is already a {type(input)}')
else:
raise TypeError(f'unknown type of note: {type(input)}')
def validate_notes(self, ids: pd.Series) -> bool:
"""Checks to make sure that all of the :class:`~budget.Note`s are contained in the ids
Parameters
----------
ids : set or like-like
:class:`list` or something that can be used in :meth:`~pandas.Series.isin`
Returns
-------
bool
`True` if all of the `Notes` in the :class:`~budget.notes.NoteManager` are in the given list of IDs
"""
return self.notes.map(lambda n: n.id).isin(ids).all()
def add_note(self, id: str, note: str, drop_dups: bool = True):
"""Parses a string into a :class:`~budget.Note` object and adds it to the :class:`~budget.notes.NoteManager` using
:class:`~pandas.Series.append` and optionally uses :class:`~pandas.Series.drop_duplicates`
Parameters
----------
id : str
id of the transaction to attach the :class:`~budget.Note` to
note : str
input string used to create the :class:`~budget.Note` object
drop_dups : bool
Whether to drop the duplicate notes
"""
n = self.parse_note(id, note)
self.notes = self.notes.append([pd.Series([n], index=[n.id])])
if drop_dups:
self.drop_duplicates()
def drop(self, id: str, note_text: str):
"""Drops a specific :class:`~budget.Note` using its ID and text
Parameters
----------
id : str
id of the note to drop
note_text : str
text of the note to drop
"""
print(f'Dropping note from {id}: {note_text}')
self.notes = self.notes[~self.notes.apply(
lambda n: (n.note == note_text) and (n.id == id)
)]
def drop_duplicates(self):
"""Removes duplicate `Notes` in the :class:`~budget.notes.NoteManager`
"""
self.notes = self.notes[~self.notes.map(repr).duplicated()]
def save_notes(self, con):
self.notes.map(repr).to_sql(name=self.SQL_NOTE_TABLE, con=con, if_exists='replace')
def get_notes_by_id(self, ids: List[str]) -> pd.Series:
"""Gets the notes that match the IDs in the given list
Parameters
----------
ids : List[str]
list of ids to get the notes
Returns
-------
:class:`~pandas.Series`
"""
return self.notes[self.notes.apply(lambda n: n.id in ids)]
def get_notes_by_type(self, typ: type) -> pd.Series:
"""Gets the notes that match the given type
Parameters
----------
typ : type
type of :class:`~budget.Note` to get
Returns
-------
:class:`~pandas.Series`
"""
# doesn't use isinstance() to prevent subtypes from being selected
return self.notes[self.notes.apply(lambda n: type(n) is typ)]
def manual_ids(self, cat: str) -> np.ndarray:
"""Gets ids of transactions that have been manually categorized as the given category
Parameters
----------
cat : str
category of transactions to get IDs for
Returns
-------
:class:`~numpy.ndarray`
"""
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a Category type and have a matching categorization
lambda n: isinstance(n, note.Category) and n.category == cat
)
].apply(lambda n: n.id).values
def split_ids(self, cat: str) -> pd.Series:
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a SplitNote type and have the category in one of its parts
lambda n: isinstance(n, split.SplitNote) and cat in n.parts
)
# convert to the value of the id attribute of each note
].apply(lambda n: n.id)
def linked_ids(self, df: pd.DataFrame) -> np.ndarray:
"""Gets ids of transactions that target those in the given DataFrame
Example
Transactions A and B are both linked to transaction C, which appears in the given DataFrame
Returns a Series of ids that include the ids of A and B
Returns
-------
:class:`~numpy.ndarray`: str
"""
return self.notes[
# select from notes
self.notes.apply(
# the ones which are both a Link type and have a target id in the given DataFrame
lambda n: isinstance(n, note.Link) and n.target in df['id'].values
)
# convert to the value of the id attribute of each note
].apply(lambda n: n.id).values
def apply_linked(self, df: pd.DataFrame) -> pd.DataFrame:
"""Applies Link notes in the given DataFrame, adding the value of each linked transaction onto the one it targets
The DataFrame needs to include both the original transactions and the ones linked to them. The values of the linked
transactions will be set to 0 as they are added onto the target transaction
Parameters
----------
df : :class:`~pandas.DataFrame`
transactions to apply the linked notes to
Returns
-------
:class:`~pandas.DataFrame`
:class:`~pandas.DataFrame` of the modified transactions
"""
link_notes = self.get_notes_by_type(note.Link)
source_in_df = link_notes.apply(lambda n: n.id in df['id'].values)
target_in_df = link_notes.apply(lambda n: n.target in df['id'].values)
# assert (target_in_df & ~source_in_df).any()
df = df | """Class to handle higher-level :class:`~budget.Note` manipulation
Attributes
----------
notes : :class:`~pandas.DataFrame`
:class:`~pandas.DataFrame` of the :class:`~budget.Note` objects. `Index` is the :class:`str` ID of the
transaction that each :class:`~budget.Note` is linked to
"""
SQL_NOTE_TABLE = 'notes'
def __init__(self):
self.notes = pd.Series(name='note', dtype='object')
self.logger = logging.getLogger(__name__)
def load_notes(self, con) -> pd.Series:
"""Loads the :class:`~budget.Note` :class:`~pandas.Series` using a connection to a SQL database using
| identifier_body | |
payment.component.ts | EventEmitter, NgZone } from '@angular/core';
import { Http, Response, RequestOptions, Headers } from '@angular/http';
import { Router, ActivatedRoute } from '@angular/router';
import { AppService } from '../app-service.service';
import { AlertService } from '../alert.service';
import { LoaderService } from '../loader.service';
import { LoggerService } from '../logger.service';
import { environment } from '../../environments/environment';
import { NotificationsService } from 'angular2-notifications';
import { Title } from '@angular/platform-browser';
declare var Razorpay: any;
declare var $: any;
@Component({
selector: 'app-payment',
templateUrl: './payment.component.html',
styleUrls: ['./payment.component.scss'],
encapsulation: ViewEncapsulation.None
})
export class PaymentComponent implements OnInit {
// @Input() tab: string;
// @Input() user;
@Output() renewalDateUpdated: EventEmitter<any> = new EventEmitter();
@Output() planTypeUpdated: EventEmitter<any> = new EventEmitter();
httpOptions: RequestOptions;
session: any;
billingAmount: any;
invoices: any;
environment: any;
subscription: any;
isPlanActive: Boolean;
payments: any;
selectedDate: any;
selectedCurrency: string;
settingsTab: string;
paymentMethod: string;
step1: any;
activeAccordion: string;
durations:Array<any>;
planDuration:string;
currentInvoice = null;
constructor(private http: Http, private router: Router, private route: ActivatedRoute,
private _appService: AppService, private loadingService: LoaderService,
private alertService: AlertService, private notify: NotificationsService,
private loggerService: LoggerService, private ngZone: NgZone, private titleService: Title) { }
ngOnInit() {
this.titleService.setTitle('Payments and Subscription | OCLAVI');
this.loadingService.show('Getting your payment details...');
this.environment = environment;
this.httpOptions = new RequestOptions({ withCredentials: true });
this.session = JSON.parse(localStorage.getItem('user'));
this.selectedCurrency = 'USD';
this.paymentMethod = 'razorpay';
this.isPlanActive = true;
if (this.session.USER_TYPE == environment.USER_TYPE.TEAM.NAME) {
this.router.navigate(['profile']);
}
if (this.session.USER_TYPE == environment.USER_TYPE.ADMIN.NAME || this.session.USER_TYPE == environment.USER_TYPE.SELF.NAME) {
if (this.session.PLAN_END_DATE < (new Date().getTime())) {
this.alertService.show('error', 'Your subscription has expired. Please upgrade');
this.isPlanActive = false;
}
}
this.subscription = {
startDate: '',
nextDueDate: '',
subscriptionPlan: '',
lastPaymentStatus: 'Successfull'
}
this.durations = [{
durationLabel: '1 Month',
durationValue: 1,
}, {
durationLabel: '3 Months',
durationValue: 3,
}, {
durationLabel: '6 Months',
durationValue: 6,
}, {
durationLabel: '1 Year',
durationValue: 12,
}]
this.step1 = {
step: 1,
title: 'upgrage_plan_payment',
content: `Payments Section`,
class: '',
status: 'inactive',
methods: [{
name: 'razorpay',
description: 'For Indian Credit / Debit Cards'
}, {
name: 'paypal',
description: 'For international cards'
}],
location: '',
selectedMethod: 'razorpay'
};
this.http.get(environment.oclaviServer + 'subscriptionDetails', this.httpOptions).subscribe(res => {
this.payments = res.json();
this.loadingService.hide();
}, err => {
this.errorHandler(err, 'Error feteching subscription details.');
});
}
durationChanged(duration) {
this.planDuration = duration.durationValue;
}
cancelSubscription() {
this.alertService.show('warn', 'Your active subscription would be cancelled.<br /><br />Are you sure you want to cancel your subscription?');
this.alertService.positiveCallback = (() => {
this.alertService.hide();
this.loadingService.show('Cancelling your subscription details...');
this.session = JSON.parse(localStorage.getItem('user'));
this.http.post(environment.oclaviServer + 'cancelSubscription', { purpose: 'CANCEL_SUBSCRIPTION' }, this.httpOptions).subscribe(res => {
this.notify.success('Your subscription has been successfully cancelled.');
if (this.session.USER_TYPE == environment.USER_TYPE.ADMIN.NAME)
this.session.USER_TYPE = environment.USER_TYPE.STUDENT_ADMIN.NAME;
else if (this.session.USER_TYPE == environment.USER_TYPE.SELF.NAME)
this.session.USER_TYPE = environment.USER_TYPE.STUDENT_SELF.NAME;
this.session.STATUS = 'PENDING_FOR_CANCELLATION';
localStorage.setItem('user', JSON.stringify(this.session));
this.planTypeUpdated.emit(this.session.USER_TYPE);
this.loadingService.hide();
}, err => {
this.errorHandler(err, 'Error cancelling your subscription.');
});
});
}
openModal(id) {
for (let i = 1; i <= 1; i++) {
if (i === 1) {
this['step' + i].status = 'active';
this['step' + i].class = 'show';
this.activeAccordion = this['step' + i].title.replace(/_/g, ' ');
} else {
this['step' + i].status = 'inactive';
this['step' + i].class = '';
}
}
$('#' + id).modal(open);
}
payNow(vm, paymentMethod) {
$('#upgradePaymentModal').modal('hide');
if (paymentMethod == 'paypal')
vm.paypalCheckout(vm);
else if (paymentMethod == 'razorpay')
vm.razorpayCheckout(vm);
}
changeSettingsTab(tab) {
this.settingsTab = tab;
}
showPaymentModal() {
if(!this.planDuration || this.planDuration == '') {
this.notify.error('Please select plan duration.');
return;
}
this.loadingService.show('Loading payment information. Please wait...');
this.http.post(environment.oclaviServer + 'getBillingAmount', { type: 'upgrade', planDuration: this.planDuration }, this.httpOptions).subscribe(res => {
this.loadingService.hide();
this.openModal('upgradePaymentModal');
this.billingAmount = res.json();
this.billingAmount.planEndDate += ((new Date()).getTimezoneOffset() * 60 * 1000);
}, err => {
this.errorHandler(err, 'Error upgrading your subscription.');
});
}
razorpayCheckout(vm) {
vm.http.post(environment.oclaviServer + 'razorpay/getModalData', { type: 'upgrade', planDuration: this.planDuration }, vm.httpOptions).subscribe(res => {
vm.loadingService.hide();
let data = res.json();
if(data.AMOUNT < 100)
data.AMOUNT = 100;
var options = {
key: data.KEY,
name: data.MERCHANT_NAME,
amount: data.AMOUNT,
description: data.DESCRIPTION,
image: '../assets/images/Oclavi_Logo@2x.png',
prefill: {
name: data.EMAIL_ID,
email: data.EMAIL_ID | },
handler: (response) => {
vm.ngZone.run(() => {
data.PAYMENT_ID = response.razorpay_payment_id;
data.PAYMENT_SOURCE = 'RAZOR_PAY';
data.PLAN_START_DATE = vm.billingAmount.planStartDate;
data.PLAN_END_DATE = vm.billingAmount.planEndDate;
vm.http.post(environment.oclaviServer + 'upgradePlan', data, vm.httpOptions).subscribe(res => {
vm.router.navigate(['/payment-status/razorpay/success/upgrade'], {
queryParams: {
razorpay_payment_id: response.razorpay_payment_id
}
});
});
});
}
}
var razorpay = new Razorpay(options);
razorpay.open();
}, err => {
vm.errorHandler(err, 'Error upgrading your subscription.');
});
}
paymentMethodChanged($event) {
this.paymentMethod = $event.target.value;
if (this.paymentMethod == 'paypal')
this.selectedCurrency = 'USD';
else if (this.paymentMethod == 'razorpay')
this.selectedCurrency = 'INR';
}
paypalCheckout(vm) {
vm.loadingService.show('Creating your paypal transaction...');
vm.http.post(environment.oclaviServer + 'upgradePlan', { PAYMENT_SOURCE: 'PAYPAL', planDuration: this.planDuration }, vm.httpOptions).subscribe(res => {
vm.loadingService.show('Redirecting to payment page...');
var body = res.json();
window.location.href = body.approval_url;
}, err => {
vm.errorHandler(err, 'Error while buying more seats...');
});
}
selectInvoiceDate(newSelectedDate) {
this.selectedDate = newSelectedDate;
}
errorHandler(response, message) {
this.loadingService.hide();
if (response.status == 401) {
this.router.navigate(['login']);
localStorage.removeItem('user');
}
else {
var text = JSON.parse(response._body).message;
if (!text || text == '')
this.notify.error(null, message);
| },
theme: {
color: '#3D78E0' | random_line_split |
payment.component.ts | , NgZone } from '@angular/core';
import { Http, Response, RequestOptions, Headers } from '@angular/http';
import { Router, ActivatedRoute } from '@angular/router';
import { AppService } from '../app-service.service';
import { AlertService } from '../alert.service';
import { LoaderService } from '../loader.service';
import { LoggerService } from '../logger.service';
import { environment } from '../../environments/environment';
import { NotificationsService } from 'angular2-notifications';
import { Title } from '@angular/platform-browser';
declare var Razorpay: any;
declare var $: any;
@Component({
selector: 'app-payment',
templateUrl: './payment.component.html',
styleUrls: ['./payment.component.scss'],
encapsulation: ViewEncapsulation.None
})
export class | implements OnInit {
// @Input() tab: string;
// @Input() user;
@Output() renewalDateUpdated: EventEmitter<any> = new EventEmitter();
@Output() planTypeUpdated: EventEmitter<any> = new EventEmitter();
httpOptions: RequestOptions;
session: any;
billingAmount: any;
invoices: any;
environment: any;
subscription: any;
isPlanActive: Boolean;
payments: any;
selectedDate: any;
selectedCurrency: string;
settingsTab: string;
paymentMethod: string;
step1: any;
activeAccordion: string;
durations:Array<any>;
planDuration:string;
currentInvoice = null;
constructor(private http: Http, private router: Router, private route: ActivatedRoute,
private _appService: AppService, private loadingService: LoaderService,
private alertService: AlertService, private notify: NotificationsService,
private loggerService: LoggerService, private ngZone: NgZone, private titleService: Title) { }
ngOnInit() {
this.titleService.setTitle('Payments and Subscription | OCLAVI');
this.loadingService.show('Getting your payment details...');
this.environment = environment;
this.httpOptions = new RequestOptions({ withCredentials: true });
this.session = JSON.parse(localStorage.getItem('user'));
this.selectedCurrency = 'USD';
this.paymentMethod = 'razorpay';
this.isPlanActive = true;
if (this.session.USER_TYPE == environment.USER_TYPE.TEAM.NAME) {
this.router.navigate(['profile']);
}
if (this.session.USER_TYPE == environment.USER_TYPE.ADMIN.NAME || this.session.USER_TYPE == environment.USER_TYPE.SELF.NAME) {
if (this.session.PLAN_END_DATE < (new Date().getTime())) {
this.alertService.show('error', 'Your subscription has expired. Please upgrade');
this.isPlanActive = false;
}
}
this.subscription = {
startDate: '',
nextDueDate: '',
subscriptionPlan: '',
lastPaymentStatus: 'Successfull'
}
this.durations = [{
durationLabel: '1 Month',
durationValue: 1,
}, {
durationLabel: '3 Months',
durationValue: 3,
}, {
durationLabel: '6 Months',
durationValue: 6,
}, {
durationLabel: '1 Year',
durationValue: 12,
}]
this.step1 = {
step: 1,
title: 'upgrage_plan_payment',
content: `Payments Section`,
class: '',
status: 'inactive',
methods: [{
name: 'razorpay',
description: 'For Indian Credit / Debit Cards'
}, {
name: 'paypal',
description: 'For international cards'
}],
location: '',
selectedMethod: 'razorpay'
};
this.http.get(environment.oclaviServer + 'subscriptionDetails', this.httpOptions).subscribe(res => {
this.payments = res.json();
this.loadingService.hide();
}, err => {
this.errorHandler(err, 'Error feteching subscription details.');
});
}
durationChanged(duration) {
this.planDuration = duration.durationValue;
}
cancelSubscription() {
this.alertService.show('warn', 'Your active subscription would be cancelled.<br /><br />Are you sure you want to cancel your subscription?');
this.alertService.positiveCallback = (() => {
this.alertService.hide();
this.loadingService.show('Cancelling your subscription details...');
this.session = JSON.parse(localStorage.getItem('user'));
this.http.post(environment.oclaviServer + 'cancelSubscription', { purpose: 'CANCEL_SUBSCRIPTION' }, this.httpOptions).subscribe(res => {
this.notify.success('Your subscription has been successfully cancelled.');
if (this.session.USER_TYPE == environment.USER_TYPE.ADMIN.NAME)
this.session.USER_TYPE = environment.USER_TYPE.STUDENT_ADMIN.NAME;
else if (this.session.USER_TYPE == environment.USER_TYPE.SELF.NAME)
this.session.USER_TYPE = environment.USER_TYPE.STUDENT_SELF.NAME;
this.session.STATUS = 'PENDING_FOR_CANCELLATION';
localStorage.setItem('user', JSON.stringify(this.session));
this.planTypeUpdated.emit(this.session.USER_TYPE);
this.loadingService.hide();
}, err => {
this.errorHandler(err, 'Error cancelling your subscription.');
});
});
}
openModal(id) {
for (let i = 1; i <= 1; i++) {
if (i === 1) {
this['step' + i].status = 'active';
this['step' + i].class = 'show';
this.activeAccordion = this['step' + i].title.replace(/_/g, ' ');
} else {
this['step' + i].status = 'inactive';
this['step' + i].class = '';
}
}
$('#' + id).modal(open);
}
payNow(vm, paymentMethod) {
$('#upgradePaymentModal').modal('hide');
if (paymentMethod == 'paypal')
vm.paypalCheckout(vm);
else if (paymentMethod == 'razorpay')
vm.razorpayCheckout(vm);
}
changeSettingsTab(tab) {
this.settingsTab = tab;
}
showPaymentModal() {
if(!this.planDuration || this.planDuration == '') {
this.notify.error('Please select plan duration.');
return;
}
this.loadingService.show('Loading payment information. Please wait...');
this.http.post(environment.oclaviServer + 'getBillingAmount', { type: 'upgrade', planDuration: this.planDuration }, this.httpOptions).subscribe(res => {
this.loadingService.hide();
this.openModal('upgradePaymentModal');
this.billingAmount = res.json();
this.billingAmount.planEndDate += ((new Date()).getTimezoneOffset() * 60 * 1000);
}, err => {
this.errorHandler(err, 'Error upgrading your subscription.');
});
}
razorpayCheckout(vm) {
vm.http.post(environment.oclaviServer + 'razorpay/getModalData', { type: 'upgrade', planDuration: this.planDuration }, vm.httpOptions).subscribe(res => {
vm.loadingService.hide();
let data = res.json();
if(data.AMOUNT < 100)
data.AMOUNT = 100;
var options = {
key: data.KEY,
name: data.MERCHANT_NAME,
amount: data.AMOUNT,
description: data.DESCRIPTION,
image: '../assets/images/Oclavi_Logo@2x.png',
prefill: {
name: data.EMAIL_ID,
email: data.EMAIL_ID
},
theme: {
color: '#3D78E0'
},
handler: (response) => {
vm.ngZone.run(() => {
data.PAYMENT_ID = response.razorpay_payment_id;
data.PAYMENT_SOURCE = 'RAZOR_PAY';
data.PLAN_START_DATE = vm.billingAmount.planStartDate;
data.PLAN_END_DATE = vm.billingAmount.planEndDate;
vm.http.post(environment.oclaviServer + 'upgradePlan', data, vm.httpOptions).subscribe(res => {
vm.router.navigate(['/payment-status/razorpay/success/upgrade'], {
queryParams: {
razorpay_payment_id: response.razorpay_payment_id
}
});
});
});
}
}
var razorpay = new Razorpay(options);
razorpay.open();
}, err => {
vm.errorHandler(err, 'Error upgrading your subscription.');
});
}
paymentMethodChanged($event) {
this.paymentMethod = $event.target.value;
if (this.paymentMethod == 'paypal')
this.selectedCurrency = 'USD';
else if (this.paymentMethod == 'razorpay')
this.selectedCurrency = 'INR';
}
paypalCheckout(vm) {
vm.loadingService.show('Creating your paypal transaction...');
vm.http.post(environment.oclaviServer + 'upgradePlan', { PAYMENT_SOURCE: 'PAYPAL', planDuration: this.planDuration }, vm.httpOptions).subscribe(res => {
vm.loadingService.show('Redirecting to payment page...');
var body = res.json();
window.location.href = body.approval_url;
}, err => {
vm.errorHandler(err, 'Error while buying more seats...');
});
}
selectInvoiceDate(newSelectedDate) {
this.selectedDate = newSelectedDate;
}
errorHandler(response, message) {
this.loadingService.hide();
if (response.status == 401) {
this.router.navigate(['login']);
localStorage.removeItem('user');
}
else {
var text = JSON.parse(response._body).message;
if (!text || text == '')
this.notify.error(null, message);
| PaymentComponent | identifier_name |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.