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 |
|---|---|---|---|---|
combat.rs
|
pub fn target_tile(tcod: &mut Tcod,
objects: &[Object], game: &mut Game,
max_range: Option<f32>)
-> Option<(i32, i32)> {
use tcod::input::KeyCode::Escape;
loop {
// render the screen. this erases the inventory and shows the names of
// objects under the mouse.
tcod.root.flush();
let event = input::check_for_event(input::KEY_PRESS | input::MOUSE).map(|e| e.1);
let mut key = None;
match event {
Some(Event::Mouse(m)) => tcod.mouse = m,
Some(Event::Key(k)) => key = Some(k),
None => {}
}
render_all(tcod, objects, game, false);
let (x, y) = (tcod.mouse.cx as i32, tcod.mouse.cy as i32);
// accept the target if the player clicked in FOV, and in case a range
// is specified, if it's in that range
let in_fov = (x < MAP_WIDTH) && (y < MAP_HEIGHT) && tcod.fov.is_in_fov(x, y);
let in_range = max_range.map_or(
true, |range| objects[PLAYER].distance(x, y) <= range);
if tcod.mouse.lbutton_pressed && in_fov && in_range {
return Some((x, y))
}
let escape = key.map_or(false, |k| k.code == Escape);
if tcod.mouse.rbutton_pressed || escape {
return None // cancel if the player right-clicked or pressed Escape
}
}
}
/// find closest enemy, up to a maximum range, and in the player's FOV
pub fn closest_monster(max_range: i32, objects: &mut [Object], tcod: &Tcod) -> Option<usize> {
let mut closest_enemy = None;
let mut closest_dist = (max_range + 1) as f32; // start with (slightly more than) maximum range
for (id, object) in objects.iter().enumerate() {
if (id != PLAYER) && object.fighter.is_some() && object.ai.is_some() &&
tcod.fov.is_in_fov(object.x, object.y)
{
// calculate distance between this object and the player
let dist = objects[PLAYER].distance_to(object);
if dist < closest_dist { // it's closer, so remember it
closest_enemy = Some(id);
closest_dist = dist;
}
}
}
closest_enemy
}
pub fn cast_fireball(_inventory_id: usize, objects: &mut [Object],game: &mut Game, tcod: &mut Tcod)
-> UseResult
{
// ask the player for a target tile to throw a fireball at
game.log.add("Left-click a target tile for the fireball, or right-click to cancel.",
colors::LIGHT_CYAN);
let (x, y) = match target_tile(tcod, objects, game, None) {
Some(tile_pos) => tile_pos,
None => return UseResult::Cancelled,
};
game.log.add(format!("The fireball explodes, burning everything within {} tiles!", FIREBALL_RADIUS),
colors::ORANGE);
let mut xp_to_gain = 0;
for (id, obj) in objects.iter_mut().enumerate() {
if obj.distance(x, y) <= FIREBALL_RADIUS as f32 && obj.fighter.is_some() {
game.log.add(format!("The {} gets burned for {} hit points.", obj.name, FIREBALL_DAMAGE),
colors::ORANGE);
if let Some(xp) = obj.take_damage(FIREBALL_DAMAGE, game) {
// Don't reward the player for burning themself!
if id != PLAYER {
xp_to_gain += xp;
}
}
}
}
objects[PLAYER].fighter.as_mut().unwrap().xp += xp_to_gain;
UseResult::UsedUp
}
pub fn cast_heal(_inventory_id: usize, objects: &mut [Object], game: &mut Game, _tcod: &mut Tcod)
-> UseResult
{
// heal the player
let player = &mut objects[PLAYER];
if let Some(fighter) = player.fighter {
if fighter.hp == player.max_hp(game) {
game.log.add("You are already at full health.", colors::RED);
return UseResult::Cancelled;
}
game.log.add("Your wounds start to feel better!", colors::LIGHT_VIOLET);
player.heal(HEAL_AMOUNT, game);
return UseResult::UsedUp;
}
UseResult::Cancelled
}
pub fn cast_lightning(_inventory_id: usize, objects: &mut [Object], game: &mut Game, tcod: &mut Tcod) -> UseResult
{
// find closest enemy (inside a maximum range) and damage it
let monster_id = closest_monster(LIGHTNING_RANGE, objects, tcod);
if let Some(monster_id) = monster_id {
// zap it!
game.log.add(format!("A lightning bolt strikes the {} with a loud thunder! \
The damage is {} hit points.",
objects[monster_id].name, LIGHTNING_DAMAGE),
colors::LIGHT_BLUE);
objects[monster_id].take_damage(LIGHTNING_DAMAGE, game);
UseResult::UsedUp
} else { // no enemy found within maximum range
game.log.add("No enemy is close enough to strike.", colors::RED);
UseResult::Cancelled
}
}
pub fn cast_confuse(_inventory_id: usize, objects: &mut [Object], game: &mut Game,tcod: &mut Tcod)
-> UseResult
{
// ask the player for a target to confuse
game.log.add("Left-click an enemy to confuse it, or right-click to cancel.", colors::LIGHT_CYAN);
let monster_id = target_monster(tcod, objects, game, Some(CONFUSE_RANGE as f32));
if let Some(monster_id) = monster_id {
let old_ai = objects[monster_id].ai.take().unwrap_or(Ai::Basic);
// replace the monster's AI with a "confused" one; after
// some turns it will restore the old AI
objects[monster_id].ai = Some(Ai::Confused {
previous_ai: Box::new(old_ai),
num_turns: CONFUSE_NUM_TURNS,
});
game.log.add(format!("The eyes of {} look vacant, as he starts to stumble around!",
objects[monster_id].name),
colors::LIGHT_GREEN);
UseResult::UsedUp
} else { // no enemy fonud within maximum range
game.log.add("No enemy is close enough to strike.", colors::RED);
UseResult::Cancelled
}
}
pub fn player_death(player: &mut Object, messages: &mut Messages)
|
pub fn monster_death(monster: &mut Object, messages: &mut Messages) {
// transform it into a nasty corpse! it doesn't block, can't be
// attacked and doesn't move
// TODO Replace with game.log.add()
// message(messages, format!("{} is dead!", monster.name), colors::ORANGE);
message(messages, format!("{} is dead! You gain {} experience points.",
monster.name, monster.fighter.unwrap().xp), colors::ORANGE);
monster.char = CORPSE;
monster.color = colors::DARK_RED;
monster.blocks = false;
monster.fighter = None;
monster.ai = None;
monster.name = format!("remains of {}", monster.name);
}
pub fn player_move_or_attack(dx: i32, dy: i32, objects: &mut [Object], game: &mut Game) {
// the coordinates the player is moving to/attacking
let x = objects[PLAYER].x + dx;
let y = objects[PLAYER].y + dy;
// try to find an attackable object there
let target_id = objects.iter().position(|object| {
object.fighter.is_some() && object.pos() == (x, y)
});
// attack if target found, move otherwise
match target_id {
Some(target_id) => {
let (player, target) = mut_two(PLAYER, target_id, objects);
player.attack(target, game);
}
None => {
move_by(PLAYER, dx, dy, &mut game.map, objects);
}
}
}
pub fn ai_take_turn(monster_id: usize, objects: &mut [Object], game: &mut Game, fov_map: &FovMap) {
use Ai::*;
if let Some(ai) = objects[monster_id].ai.take() {
let new_ai = match ai {
Basic => ai_basic(monster_id, game, objects, fov_map),
Confused{previous_ai, num_turns} => ai_confused(
monster_id, &mut game.map, objects, &mut game.log, previous_ai, num_turns)
};
objects[monster_id].
|
{
// the game ended!
// TODO Replace with game.log.add()
message(messages, "You died!", colors::DARK_RED);
// for added effect, transform the player into a corpse!
player.char = CORPSE;
player.color = colors::DARK_RED;
}
|
identifier_body
|
combat.rs
|
pub fn target_tile(tcod: &mut Tcod,
objects: &[Object], game: &mut Game,
max_range: Option<f32>)
-> Option<(i32, i32)> {
use tcod::input::KeyCode::Escape;
loop {
// render the screen. this erases the inventory and shows the names of
// objects under the mouse.
tcod.root.flush();
let event = input::check_for_event(input::KEY_PRESS | input::MOUSE).map(|e| e.1);
let mut key = None;
match event {
Some(Event::Mouse(m)) => tcod.mouse = m,
Some(Event::Key(k)) => key = Some(k),
None =>
|
}
render_all(tcod, objects, game, false);
let (x, y) = (tcod.mouse.cx as i32, tcod.mouse.cy as i32);
// accept the target if the player clicked in FOV, and in case a range
// is specified, if it's in that range
let in_fov = (x < MAP_WIDTH) && (y < MAP_HEIGHT) && tcod.fov.is_in_fov(x, y);
let in_range = max_range.map_or(
true, |range| objects[PLAYER].distance(x, y) <= range);
if tcod.mouse.lbutton_pressed && in_fov && in_range {
return Some((x, y))
}
let escape = key.map_or(false, |k| k.code == Escape);
if tcod.mouse.rbutton_pressed || escape {
return None // cancel if the player right-clicked or pressed Escape
}
}
}
/// find closest enemy, up to a maximum range, and in the player's FOV
pub fn closest_monster(max_range: i32, objects: &mut [Object], tcod: &Tcod) -> Option<usize> {
let mut closest_enemy = None;
let mut closest_dist = (max_range + 1) as f32; // start with (slightly more than) maximum range
for (id, object) in objects.iter().enumerate() {
if (id != PLAYER) && object.fighter.is_some() && object.ai.is_some() &&
tcod.fov.is_in_fov(object.x, object.y)
{
// calculate distance between this object and the player
let dist = objects[PLAYER].distance_to(object);
if dist < closest_dist { // it's closer, so remember it
closest_enemy = Some(id);
closest_dist = dist;
}
}
}
closest_enemy
}
pub fn cast_fireball(_inventory_id: usize, objects: &mut [Object],game: &mut Game, tcod: &mut Tcod)
-> UseResult
{
// ask the player for a target tile to throw a fireball at
game.log.add("Left-click a target tile for the fireball, or right-click to cancel.",
colors::LIGHT_CYAN);
let (x, y) = match target_tile(tcod, objects, game, None) {
Some(tile_pos) => tile_pos,
None => return UseResult::Cancelled,
};
game.log.add(format!("The fireball explodes, burning everything within {} tiles!", FIREBALL_RADIUS),
colors::ORANGE);
let mut xp_to_gain = 0;
for (id, obj) in objects.iter_mut().enumerate() {
if obj.distance(x, y) <= FIREBALL_RADIUS as f32 && obj.fighter.is_some() {
game.log.add(format!("The {} gets burned for {} hit points.", obj.name, FIREBALL_DAMAGE),
colors::ORANGE);
if let Some(xp) = obj.take_damage(FIREBALL_DAMAGE, game) {
// Don't reward the player for burning themself!
if id != PLAYER {
xp_to_gain += xp;
}
}
}
}
objects[PLAYER].fighter.as_mut().unwrap().xp += xp_to_gain;
UseResult::UsedUp
}
pub fn cast_heal(_inventory_id: usize, objects: &mut [Object], game: &mut Game, _tcod: &mut Tcod)
-> UseResult
{
// heal the player
let player = &mut objects[PLAYER];
if let Some(fighter) = player.fighter {
if fighter.hp == player.max_hp(game) {
game.log.add("You are already at full health.", colors::RED);
return UseResult::Cancelled;
}
game.log.add("Your wounds start to feel better!", colors::LIGHT_VIOLET);
player.heal(HEAL_AMOUNT, game);
return UseResult::UsedUp;
}
UseResult::Cancelled
}
pub fn cast_lightning(_inventory_id: usize, objects: &mut [Object], game: &mut Game, tcod: &mut Tcod) -> UseResult
{
// find closest enemy (inside a maximum range) and damage it
let monster_id = closest_monster(LIGHTNING_RANGE, objects, tcod);
if let Some(monster_id) = monster_id {
// zap it!
game.log.add(format!("A lightning bolt strikes the {} with a loud thunder! \
The damage is {} hit points.",
objects[monster_id].name, LIGHTNING_DAMAGE),
colors::LIGHT_BLUE);
objects[monster_id].take_damage(LIGHTNING_DAMAGE, game);
UseResult::UsedUp
} else { // no enemy found within maximum range
game.log.add("No enemy is close enough to strike.", colors::RED);
UseResult::Cancelled
}
}
pub fn cast_confuse(_inventory_id: usize, objects: &mut [Object], game: &mut Game,tcod: &mut Tcod)
-> UseResult
{
// ask the player for a target to confuse
game.log.add("Left-click an enemy to confuse it, or right-click to cancel.", colors::LIGHT_CYAN);
let monster_id = target_monster(tcod, objects, game, Some(CONFUSE_RANGE as f32));
if let Some(monster_id) = monster_id {
let old_ai = objects[monster_id].ai.take().unwrap_or(Ai::Basic);
// replace the monster's AI with a "confused" one; after
// some turns it will restore the old AI
objects[monster_id].ai = Some(Ai::Confused {
previous_ai: Box::new(old_ai),
num_turns: CONFUSE_NUM_TURNS,
});
game.log.add(format!("The eyes of {} look vacant, as he starts to stumble around!",
objects[monster_id].name),
colors::LIGHT_GREEN);
UseResult::UsedUp
} else { // no enemy fonud within maximum range
game.log.add("No enemy is close enough to strike.", colors::RED);
UseResult::Cancelled
}
}
pub fn player_death(player: &mut Object, messages: &mut Messages) {
// the game ended!
// TODO Replace with game.log.add()
message(messages, "You died!", colors::DARK_RED);
// for added effect, transform the player into a corpse!
player.char = CORPSE;
player.color = colors::DARK_RED;
}
pub fn monster_death(monster: &mut Object, messages: &mut Messages) {
// transform it into a nasty corpse! it doesn't block, can't be
// attacked and doesn't move
// TODO Replace with game.log.add()
// message(messages, format!("{} is dead!", monster.name), colors::ORANGE);
message(messages, format!("{} is dead! You gain {} experience points.",
monster.name, monster.fighter.unwrap().xp), colors::ORANGE);
monster.char = CORPSE;
monster.color = colors::DARK_RED;
monster.blocks = false;
monster.fighter = None;
monster.ai = None;
monster.name = format!("remains of {}", monster.name);
}
pub fn player_move_or_attack(dx: i32, dy: i32, objects: &mut [Object], game: &mut Game) {
// the coordinates the player is moving to/attacking
let x = objects[PLAYER].x + dx;
let y = objects[PLAYER].y + dy;
// try to find an attackable object there
let target_id = objects.iter().position(|object| {
object.fighter.is_some() && object.pos() == (x, y)
});
// attack if target found, move otherwise
match target_id {
Some(target_id) => {
let (player, target) = mut_two(PLAYER, target_id, objects);
player.attack(target, game);
}
None => {
move_by(PLAYER, dx, dy, &mut game.map, objects);
}
}
}
pub fn ai_take_turn(monster_id: usize, objects: &mut [Object], game: &mut Game, fov_map: &FovMap) {
use Ai::*;
if let Some(ai) = objects[monster_id].ai.take() {
let new_ai = match ai {
Basic => ai_basic(monster_id, game, objects, fov_map),
Confused{previous_ai, num_turns} => ai_confused(
monster_id, &mut game.map, objects, &mut game.log, previous_ai, num_turns)
};
objects[monster_id].
|
{}
|
conditional_block
|
combat.rs
|
objects: &[Object], game: &mut Game,
max_range: Option<f32>)
-> Option<(i32, i32)> {
use tcod::input::KeyCode::Escape;
loop {
// render the screen. this erases the inventory and shows the names of
// objects under the mouse.
tcod.root.flush();
let event = input::check_for_event(input::KEY_PRESS | input::MOUSE).map(|e| e.1);
let mut key = None;
match event {
Some(Event::Mouse(m)) => tcod.mouse = m,
Some(Event::Key(k)) => key = Some(k),
None => {}
}
render_all(tcod, objects, game, false);
let (x, y) = (tcod.mouse.cx as i32, tcod.mouse.cy as i32);
// accept the target if the player clicked in FOV, and in case a range
// is specified, if it's in that range
let in_fov = (x < MAP_WIDTH) && (y < MAP_HEIGHT) && tcod.fov.is_in_fov(x, y);
let in_range = max_range.map_or(
true, |range| objects[PLAYER].distance(x, y) <= range);
if tcod.mouse.lbutton_pressed && in_fov && in_range {
return Some((x, y))
}
let escape = key.map_or(false, |k| k.code == Escape);
if tcod.mouse.rbutton_pressed || escape {
return None // cancel if the player right-clicked or pressed Escape
}
}
}
/// find closest enemy, up to a maximum range, and in the player's FOV
pub fn closest_monster(max_range: i32, objects: &mut [Object], tcod: &Tcod) -> Option<usize> {
let mut closest_enemy = None;
let mut closest_dist = (max_range + 1) as f32; // start with (slightly more than) maximum range
for (id, object) in objects.iter().enumerate() {
if (id != PLAYER) && object.fighter.is_some() && object.ai.is_some() &&
tcod.fov.is_in_fov(object.x, object.y)
{
// calculate distance between this object and the player
let dist = objects[PLAYER].distance_to(object);
if dist < closest_dist { // it's closer, so remember it
closest_enemy = Some(id);
closest_dist = dist;
}
}
}
closest_enemy
}
pub fn cast_fireball(_inventory_id: usize, objects: &mut [Object],game: &mut Game, tcod: &mut Tcod)
-> UseResult
{
// ask the player for a target tile to throw a fireball at
game.log.add("Left-click a target tile for the fireball, or right-click to cancel.",
colors::LIGHT_CYAN);
let (x, y) = match target_tile(tcod, objects, game, None) {
Some(tile_pos) => tile_pos,
None => return UseResult::Cancelled,
};
game.log.add(format!("The fireball explodes, burning everything within {} tiles!", FIREBALL_RADIUS),
colors::ORANGE);
let mut xp_to_gain = 0;
for (id, obj) in objects.iter_mut().enumerate() {
if obj.distance(x, y) <= FIREBALL_RADIUS as f32 && obj.fighter.is_some() {
game.log.add(format!("The {} gets burned for {} hit points.", obj.name, FIREBALL_DAMAGE),
colors::ORANGE);
if let Some(xp) = obj.take_damage(FIREBALL_DAMAGE, game) {
// Don't reward the player for burning themself!
if id != PLAYER {
xp_to_gain += xp;
}
}
}
}
objects[PLAYER].fighter.as_mut().unwrap().xp += xp_to_gain;
UseResult::UsedUp
}
pub fn cast_heal(_inventory_id: usize, objects: &mut [Object], game: &mut Game, _tcod: &mut Tcod)
-> UseResult
{
// heal the player
let player = &mut objects[PLAYER];
if let Some(fighter) = player.fighter {
if fighter.hp == player.max_hp(game) {
game.log.add("You are already at full health.", colors::RED);
return UseResult::Cancelled;
}
game.log.add("Your wounds start to feel better!", colors::LIGHT_VIOLET);
player.heal(HEAL_AMOUNT, game);
return UseResult::UsedUp;
}
UseResult::Cancelled
}
pub fn cast_lightning(_inventory_id: usize, objects: &mut [Object], game: &mut Game, tcod: &mut Tcod) -> UseResult
{
// find closest enemy (inside a maximum range) and damage it
let monster_id = closest_monster(LIGHTNING_RANGE, objects, tcod);
if let Some(monster_id) = monster_id {
// zap it!
game.log.add(format!("A lightning bolt strikes the {} with a loud thunder! \
The damage is {} hit points.",
objects[monster_id].name, LIGHTNING_DAMAGE),
colors::LIGHT_BLUE);
objects[monster_id].take_damage(LIGHTNING_DAMAGE, game);
UseResult::UsedUp
} else { // no enemy found within maximum range
game.log.add("No enemy is close enough to strike.", colors::RED);
UseResult::Cancelled
}
}
pub fn cast_confuse(_inventory_id: usize, objects: &mut [Object], game: &mut Game,tcod: &mut Tcod)
-> UseResult
{
// ask the player for a target to confuse
game.log.add("Left-click an enemy to confuse it, or right-click to cancel.", colors::LIGHT_CYAN);
let monster_id = target_monster(tcod, objects, game, Some(CONFUSE_RANGE as f32));
if let Some(monster_id) = monster_id {
let old_ai = objects[monster_id].ai.take().unwrap_or(Ai::Basic);
// replace the monster's AI with a "confused" one; after
// some turns it will restore the old AI
objects[monster_id].ai = Some(Ai::Confused {
previous_ai: Box::new(old_ai),
num_turns: CONFUSE_NUM_TURNS,
});
game.log.add(format!("The eyes of {} look vacant, as he starts to stumble around!",
objects[monster_id].name),
colors::LIGHT_GREEN);
UseResult::UsedUp
} else { // no enemy fonud within maximum range
game.log.add("No enemy is close enough to strike.", colors::RED);
UseResult::Cancelled
}
}
pub fn player_death(player: &mut Object, messages: &mut Messages) {
// the game ended!
// TODO Replace with game.log.add()
message(messages, "You died!", colors::DARK_RED);
// for added effect, transform the player into a corpse!
player.char = CORPSE;
player.color = colors::DARK_RED;
}
pub fn monster_death(monster: &mut Object, messages: &mut Messages) {
// transform it into a nasty corpse! it doesn't block, can't be
// attacked and doesn't move
// TODO Replace with game.log.add()
// message(messages, format!("{} is dead!", monster.name), colors::ORANGE);
message(messages, format!("{} is dead! You gain {} experience points.",
monster.name, monster.fighter.unwrap().xp), colors::ORANGE);
monster.char = CORPSE;
monster.color = colors::DARK_RED;
monster.blocks = false;
monster.fighter = None;
monster.ai = None;
monster.name = format!("remains of {}", monster.name);
}
pub fn player_move_or_attack(dx: i32, dy: i32, objects: &mut [Object], game: &mut Game) {
// the coordinates the player is moving to/attacking
let x = objects[PLAYER].x + dx;
let y = objects[PLAYER].y + dy;
// try to find an attackable object there
let target_id = objects.iter().position(|object| {
object.fighter.is_some() && object.pos() == (x, y)
});
// attack if target found, move otherwise
match target_id {
Some(target_id) => {
let (player, target) = mut_two(PLAYER, target_id, objects);
player.attack(target, game);
}
None => {
move_by(PLAYER, dx, dy, &mut game.map, objects);
}
}
}
pub fn ai_take_turn(monster_id: usize, objects: &mut [Object], game: &mut Game, fov_map: &FovMap) {
use Ai::*;
if let Some(ai) = objects[monster_id].ai.take() {
let new_ai = match ai {
Basic => ai_basic(monster_id, game, objects, fov_map),
Confused{previous_ai, num_turns} => ai_confused(
monster_id, &mut game.map, objects, &mut game.log, previous_ai, num_turns)
};
objects[monster_id].ai = Some(new_ai);
}
}
pub fn
|
ai_basic
|
identifier_name
|
|
ikdbtest_gl.py
|
(GLPluginProgram):
def __init__(self,world,name):
GLPluginProgram.__init__(self,name)
self.widgetPlugin = GLWidgetPlugin()
self.setPlugin(self.widgetPlugin)
self.widgetMaster = self.widgetPlugin.klamptwidgetmaster
self.world = world
def display(self):
GLPluginProgram.display(self)
self.world.drawGL()
else:
NEW_KLAMPT = False
from klampt import ik,loader
from klampt.glrobotprogram import *
from klampt import PointPoser,TransformPoser
from klampt import robotcollide as collide
from klampt import se3
import sys
import traceback
import numpy as np
#preload
from sklearn.neighbors import NearestNeighbors,BallTree
class IKDBVisualTester(GLWidgetProgram):
def __init__(self,visWorld,planningWorld,name="IK Database visual tester"):
GLWidgetProgram.__init__(self,visWorld,name)
self.planningWorld = planningWorld
self.collider = collide.WorldCollider(visWorld)
self.ikdb = ManagedIKDatabase(planningWorld.robot(0))
self.ikWidgets = []
self.ikIndices = []
self.ikProblem = IKProblem()
self.ikProblem.setFeasibilityTest('collisionFree',None)
qmin,qmax = planningWorld.robot(0).getJointLimits()
self.ikProblem.setCostFunction('jointRangeCost_dynamic',[qmin,qmax])
self.drawDb = False
self.continuous = False
self.reSolve = False
self.currentConfig = self.world.robot(0).getConfig()
def mousefunc(self,button,state,x,y):
#Put your mouse handler here
#the current example prints out the list of objects clicked whenever
#you right click
GLWidgetProgram.mousefunc(self,button,state,x,y)
self.reSolve = False
dragging = False
if NEW_KLAMPT:
dragging = self.widgetPlugin.klamptwidgetdragging
else:
dragging = self.draggingWidget
if not dragging and button == 2 and state==0:
#down
clicked = self.click_world(x,y)
if clicked is not None and isinstance(clicked[0],RobotModelLink):
#make a new widget
link, wpt = clicked
lpt = se3.apply(se3.inv(link.getTransform()),wpt)
self.ikIndices.append(len(self.ikWidgets))
self.ikWidgets.append(PointPoser())
self.ikWidgets[-1].set(wpt)
self.widgetMaster.add(self.ikWidgets[-1])
self.ikProblem.addObjective(ik.objective(link,local=lpt,world=wpt))
GLWidgetProgram.mousefunc(self,button,state,x,y)
self.refresh()
return
#the dx,dy arguments are needed to be cross-compatible between 0.6.x and 0.7
def motionfunc(self,x,y,dx=0,dy=0):
dragging = False
if NEW_KLAMPT:
retval = GLWidgetProgram.motionfunc(self,x,y,dx,dy)
dragging = self.widgetPlugin.klamptwidgetdragging
else:
retval = GLWidgetProgram.motionfunc(self,x,y)
dragging = self.draggingWidget
if dragging:
#update all the IK objectives
for i in range(len(self.ikWidgets)):
index = self.ikIndices[i]
if isinstance(self.ikWidgets[i],PointPoser):
wptnew = self.ikWidgets[i].get()
obj = self.ikProblem.objectives[index]
link = obj.link()
lpt,wptold = obj.getPosition()
obj.setFixedPoint(link,lpt,wptnew)
#don't solve now, wait for refresh to process
if self.continuous and wptnew != wptold:
self.reSolve = True
elif isinstance(self.ikWidgets[i],TransformPoser):
Rnew,tnew = self.ikWidgets[i].get()
obj = self.ikProblem.objectives[index]
link = obj.link()
Rold,told = obj.getTransform()
obj.setFixedTransform(link,Rnew,tnew)
#don't solve now, wait for refresh to process
if self.continuous and (Rnew,tnew) != (Rold,told):
self.reSolve = True
return retval
def keyboardfunc(self,c,x,y):
if c=='h':
|
print ('[space]: tests the current configuration')
print ('d: deletes IK constraint')
print ('t: adds a new rotation-fixed IK constraint')
print ('f: flushes the current database to disk')
print ('s: saves the current database to disk')
print ('b: performs one background step')
print ('B: starts / stops the background thread')
print ('v: toggles display of the database')
print ('c: toggles continuous re-solving of IK constraint its as being moved')
print ('o: toggles soft / hard IK constraints')
elif c==' ':
self.planningWorld.robot(0).setConfig(self.currentConfig)
soln = self.ikdb.solve(self.ikProblem)
if soln:
print ("Solved")
self.currentConfig = soln
self.refresh()
else:
print ("Failure")
elif c=='d':
for i,w in enumerate(self.ikWidgets):
if w.hasHighlight():
print ("Deleting IK widget")
#delete it
index = self.ikIndices[i]
self.widgetMaster.remove(w)
del self.ikWidgets[i]
del self.ikIndices[i]
del self.ikProblem.objectives[index]
for j in range(len(self.ikIndices)):
self.ikIndices[j] = j
self.refresh()
break
elif c=='t':
clicked = self.click_world(x,y)
if clicked is not None and isinstance(clicked[0],RobotModelLink):
#make a new widget
link, wpt = clicked
Tlink = link.getTransform()
self.ikIndices.append(len(self.ikWidgets))
self.ikWidgets.append(TransformPoser())
self.ikWidgets[-1].set(*Tlink)
self.widgetMaster.add(self.ikWidgets[-1])
self.ikProblem.addObjective(ik.objective(link,R=Tlink[0],t=Tlink[1]))
self.refresh()
elif c=='f':
self.ikdb.flush()
elif c=='s':
self.ikdb.save()
elif c=='b':
self.ikdb.backgroundStep()
self.refresh()
elif c=='B':
if hasattr(self.ikdb,'thread'):
self.ikdb.stopBackgroundLoop()
else:
self.ikdb.startBackgroundLoop(0)
elif c=='v':
self.drawDb = not self.drawDb
elif c=='c':
self.continuous = not self.continuous
elif c == 'o':
self.ikProblem.setSoftObjectives(not self.ikProblem.softObjectives)
def display(self):
if self.reSolve:
self.planningWorld.robot(0).setConfig(self.currentConfig)
soln = self.ikdb.solve(self.ikProblem)
if soln:
self.currentConfig = soln
self.reSolve = False
self.world.robot(0).setConfig(self.currentConfig)
GLWidgetProgram.display(self)
glDisable(GL_LIGHTING)
#draw IK goals
for obj in self.ikProblem.objectives:
linkindex = obj.link()
link = self.world.robot(0).link(linkindex)
lp,wpdes = obj.getPosition()
wp = se3.apply(link.getTransform(),lp)
glLineWidth(4.0)
glDisable(GL_LIGHTING)
glColor3f(0,1,0)
glBegin(GL_LINES)
glVertex3f(*wp)
glVertex3f(*wpdes)
glEnd()
glLineWidth(1)
#draw end positions of solved problems
if self.drawDb:
glPointSize(3.0)
glBegin(GL_POINTS)
for k,db in iteritems(self.ikdb.databases):
for i in range(db.numProblems()):
try:
p = db.getProblem(i)
except Exception as e:
traceback.print_exc()
exit(0)
if db.solutions[i] is None:
glColor3f(1,0,0)
else:
glColor3f(0,0,1)
for obj in p.objectives:
lp,wpdes = obj.getPosition()
glVertex3f(*wpdes)
glColor3f(1,1,0)
for pjson,soln in self.ikdb.backburner:
p = IKProblem()
p.fromJson(pjson)
for obj in p.objectives:
lp,wpdes = obj.getPosition()
glVertex3f(*wpdes)
glEnd()
return
def click_world(self,x,y):
"""Helper: returns (obj,pt) where obj is the closest world object
clicked, and pt is the associated clicked point (in world coordinates).
If no point is clicked, returns None."""
#get the viewport ray
if NEW_KLAMPT:
(s,d) =
|
print ('HELP:')
print ('[right-click]: add a new IK constraint')
|
random_line_split
|
ikdbtest_gl.py
|
__init__(self,world,name):
GLPluginProgram.__init__(self,name)
self.widgetPlugin = GLWidgetPlugin()
self.setPlugin(self.widgetPlugin)
self.widgetMaster = self.widgetPlugin.klamptwidgetmaster
self.world = world
def display(self):
GLPluginProgram.display(self)
self.world.drawGL()
else:
NEW_KLAMPT = False
from klampt import ik,loader
from klampt.glrobotprogram import *
from klampt import PointPoser,TransformPoser
from klampt import robotcollide as collide
from klampt import se3
import sys
import traceback
import numpy as np
#preload
from sklearn.neighbors import NearestNeighbors,BallTree
class IKDBVisualTester(GLWidgetProgram):
def __init__(self,visWorld,planningWorld,name="IK Database visual tester"):
GLWidgetProgram.__init__(self,visWorld,name)
self.planningWorld = planningWorld
self.collider = collide.WorldCollider(visWorld)
self.ikdb = ManagedIKDatabase(planningWorld.robot(0))
self.ikWidgets = []
self.ikIndices = []
self.ikProblem = IKProblem()
self.ikProblem.setFeasibilityTest('collisionFree',None)
qmin,qmax = planningWorld.robot(0).getJointLimits()
self.ikProblem.setCostFunction('jointRangeCost_dynamic',[qmin,qmax])
self.drawDb = False
self.continuous = False
self.reSolve = False
self.currentConfig = self.world.robot(0).getConfig()
def mousefunc(self,button,state,x,y):
#Put your mouse handler here
#the current example prints out the list of objects clicked whenever
#you right click
GLWidgetProgram.mousefunc(self,button,state,x,y)
self.reSolve = False
dragging = False
if NEW_KLAMPT:
dragging = self.widgetPlugin.klamptwidgetdragging
else:
dragging = self.draggingWidget
if not dragging and button == 2 and state==0:
#down
clicked = self.click_world(x,y)
if clicked is not None and isinstance(clicked[0],RobotModelLink):
#make a new widget
link, wpt = clicked
lpt = se3.apply(se3.inv(link.getTransform()),wpt)
self.ikIndices.append(len(self.ikWidgets))
self.ikWidgets.append(PointPoser())
self.ikWidgets[-1].set(wpt)
self.widgetMaster.add(self.ikWidgets[-1])
self.ikProblem.addObjective(ik.objective(link,local=lpt,world=wpt))
GLWidgetProgram.mousefunc(self,button,state,x,y)
self.refresh()
return
#the dx,dy arguments are needed to be cross-compatible between 0.6.x and 0.7
def motionfunc(self,x,y,dx=0,dy=0):
dragging = False
if NEW_KLAMPT:
retval = GLWidgetProgram.motionfunc(self,x,y,dx,dy)
dragging = self.widgetPlugin.klamptwidgetdragging
else:
retval = GLWidgetProgram.motionfunc(self,x,y)
dragging = self.draggingWidget
if dragging:
#update all the IK objectives
for i in range(len(self.ikWidgets)):
index = self.ikIndices[i]
if isinstance(self.ikWidgets[i],PointPoser):
wptnew = self.ikWidgets[i].get()
obj = self.ikProblem.objectives[index]
link = obj.link()
lpt,wptold = obj.getPosition()
obj.setFixedPoint(link,lpt,wptnew)
#don't solve now, wait for refresh to process
if self.continuous and wptnew != wptold:
self.reSolve = True
elif isinstance(self.ikWidgets[i],TransformPoser):
Rnew,tnew = self.ikWidgets[i].get()
obj = self.ikProblem.objectives[index]
link = obj.link()
Rold,told = obj.getTransform()
obj.setFixedTransform(link,Rnew,tnew)
#don't solve now, wait for refresh to process
if self.continuous and (Rnew,tnew) != (Rold,told):
self.reSolve = True
return retval
def keyboardfunc(self,c,x,y):
if c=='h':
print ('HELP:')
print ('[right-click]: add a new IK constraint')
print ('[space]: tests the current configuration')
print ('d: deletes IK constraint')
print ('t: adds a new rotation-fixed IK constraint')
print ('f: flushes the current database to disk')
print ('s: saves the current database to disk')
print ('b: performs one background step')
print ('B: starts / stops the background thread')
print ('v: toggles display of the database')
print ('c: toggles continuous re-solving of IK constraint its as being moved')
print ('o: toggles soft / hard IK constraints')
elif c==' ':
self.planningWorld.robot(0).setConfig(self.currentConfig)
soln = self.ikdb.solve(self.ikProblem)
if soln:
print ("Solved")
self.currentConfig = soln
self.refresh()
else:
print ("Failure")
elif c=='d':
for i,w in enumerate(self.ikWidgets):
if w.hasHighlight():
print ("Deleting IK widget")
#delete it
index = self.ikIndices[i]
self.widgetMaster.remove(w)
del self.ikWidgets[i]
del self.ikIndices[i]
del self.ikProblem.objectives[index]
for j in range(len(self.ikIndices)):
self.ikIndices[j] = j
self.refresh()
break
elif c=='t':
clicked = self.click_world(x,y)
if clicked is not None and isinstance(clicked[0],RobotModelLink):
#make a new widget
link, wpt = clicked
Tlink = link.getTransform()
self.ikIndices.append(len(self.ikWidgets))
self.ikWidgets.append(TransformPoser())
self.ikWidgets[-1].set(*Tlink)
self.widgetMaster.add(self.ikWidgets[-1])
self.ikProblem.addObjective(ik.objective(link,R=Tlink[0],t=Tlink[1]))
self.refresh()
elif c=='f':
self.ikdb.flush()
elif c=='s':
self.ikdb.save()
elif c=='b':
self.ikdb.backgroundStep()
self.refresh()
elif c=='B':
if hasattr(self.ikdb,'thread'):
self.ikdb.stopBackgroundLoop()
else:
self.ikdb.startBackgroundLoop(0)
elif c=='v':
self.drawDb = not self.drawDb
elif c=='c':
self.continuous = not self.continuous
elif c == 'o':
self.ikProblem.setSoftObjectives(not self.ikProblem.softObjectives)
def display(self):
if self.reSolve:
self.planningWorld.robot(0).setConfig(self.currentConfig)
soln = self.ikdb.solve(self.ikProblem)
if soln:
self.currentConfig = soln
self.reSolve = False
self.world.robot(0).setConfig(self.currentConfig)
GLWidgetProgram.display(self)
glDisable(GL_LIGHTING)
#draw IK goals
for obj in self.ikProblem.objectives:
linkindex = obj.link()
link = self.world.robot(0).link(linkindex)
lp,wpdes = obj.getPosition()
wp = se3.apply(link.getTransform(),lp)
glLineWidth(4.0)
glDisable(GL_LIGHTING)
glColor3f(0,1,0)
glBegin(GL_LINES)
glVertex3f(*wp)
glVertex3f(*wpdes)
glEnd()
glLineWidth(1)
#draw end positions of solved problems
if self.drawDb:
glPointSize(3.0)
glBegin(GL_POINTS)
for k,db in iteritems(self.ikdb.databases):
for i in range(db.numProblems()):
try:
p = db.getProblem(i)
except Exception as e:
traceback.print_exc()
exit(0)
if db.solutions[i] is None:
glColor3f(1,0,0)
else:
glColor3f(0,0,1)
for obj in p.objectives:
lp,wpdes = obj.getPosition()
glVertex3f(*wpdes)
glColor3f(1,1,0)
for pjson,soln in self.ikdb.backburner:
p = IKProblem()
p.fromJson(pjson)
for obj in p.objectives:
lp,wpdes = obj.getPosition()
glVertex3f(*wpdes)
glEnd()
return
def click_world(self,x,y):
"""Helper: returns (obj,pt) where obj is the closest world object
clicked, and pt is the associated clicked point (in world coordinates).
If no point is clicked, returns None."""
#get the viewport ray
if NEW_KLAMPT:
|
(s,d) = self.view.click_ray(x,y)
|
conditional_block
|
|
ikdbtest_gl.py
|
PluginProgram):
def __init__(self,world,name):
GLPluginProgram.__init__(self,name)
self.widgetPlugin = GLWidgetPlugin()
self.setPlugin(self.widgetPlugin)
self.widgetMaster = self.widgetPlugin.klamptwidgetmaster
self.world = world
def display(self):
GLPluginProgram.display(self)
self.world.drawGL()
else:
NEW_KLAMPT = False
from klampt import ik,loader
from klampt.glrobotprogram import *
from klampt import PointPoser,TransformPoser
from klampt import robotcollide as collide
from klampt import se3
import sys
import traceback
import numpy as np
#preload
from sklearn.neighbors import NearestNeighbors,BallTree
class IKDBVisualTester(GLWidgetProgram):
def
|
(self,visWorld,planningWorld,name="IK Database visual tester"):
GLWidgetProgram.__init__(self,visWorld,name)
self.planningWorld = planningWorld
self.collider = collide.WorldCollider(visWorld)
self.ikdb = ManagedIKDatabase(planningWorld.robot(0))
self.ikWidgets = []
self.ikIndices = []
self.ikProblem = IKProblem()
self.ikProblem.setFeasibilityTest('collisionFree',None)
qmin,qmax = planningWorld.robot(0).getJointLimits()
self.ikProblem.setCostFunction('jointRangeCost_dynamic',[qmin,qmax])
self.drawDb = False
self.continuous = False
self.reSolve = False
self.currentConfig = self.world.robot(0).getConfig()
def mousefunc(self,button,state,x,y):
#Put your mouse handler here
#the current example prints out the list of objects clicked whenever
#you right click
GLWidgetProgram.mousefunc(self,button,state,x,y)
self.reSolve = False
dragging = False
if NEW_KLAMPT:
dragging = self.widgetPlugin.klamptwidgetdragging
else:
dragging = self.draggingWidget
if not dragging and button == 2 and state==0:
#down
clicked = self.click_world(x,y)
if clicked is not None and isinstance(clicked[0],RobotModelLink):
#make a new widget
link, wpt = clicked
lpt = se3.apply(se3.inv(link.getTransform()),wpt)
self.ikIndices.append(len(self.ikWidgets))
self.ikWidgets.append(PointPoser())
self.ikWidgets[-1].set(wpt)
self.widgetMaster.add(self.ikWidgets[-1])
self.ikProblem.addObjective(ik.objective(link,local=lpt,world=wpt))
GLWidgetProgram.mousefunc(self,button,state,x,y)
self.refresh()
return
#the dx,dy arguments are needed to be cross-compatible between 0.6.x and 0.7
def motionfunc(self,x,y,dx=0,dy=0):
dragging = False
if NEW_KLAMPT:
retval = GLWidgetProgram.motionfunc(self,x,y,dx,dy)
dragging = self.widgetPlugin.klamptwidgetdragging
else:
retval = GLWidgetProgram.motionfunc(self,x,y)
dragging = self.draggingWidget
if dragging:
#update all the IK objectives
for i in range(len(self.ikWidgets)):
index = self.ikIndices[i]
if isinstance(self.ikWidgets[i],PointPoser):
wptnew = self.ikWidgets[i].get()
obj = self.ikProblem.objectives[index]
link = obj.link()
lpt,wptold = obj.getPosition()
obj.setFixedPoint(link,lpt,wptnew)
#don't solve now, wait for refresh to process
if self.continuous and wptnew != wptold:
self.reSolve = True
elif isinstance(self.ikWidgets[i],TransformPoser):
Rnew,tnew = self.ikWidgets[i].get()
obj = self.ikProblem.objectives[index]
link = obj.link()
Rold,told = obj.getTransform()
obj.setFixedTransform(link,Rnew,tnew)
#don't solve now, wait for refresh to process
if self.continuous and (Rnew,tnew) != (Rold,told):
self.reSolve = True
return retval
def keyboardfunc(self,c,x,y):
if c=='h':
print ('HELP:')
print ('[right-click]: add a new IK constraint')
print ('[space]: tests the current configuration')
print ('d: deletes IK constraint')
print ('t: adds a new rotation-fixed IK constraint')
print ('f: flushes the current database to disk')
print ('s: saves the current database to disk')
print ('b: performs one background step')
print ('B: starts / stops the background thread')
print ('v: toggles display of the database')
print ('c: toggles continuous re-solving of IK constraint its as being moved')
print ('o: toggles soft / hard IK constraints')
elif c==' ':
self.planningWorld.robot(0).setConfig(self.currentConfig)
soln = self.ikdb.solve(self.ikProblem)
if soln:
print ("Solved")
self.currentConfig = soln
self.refresh()
else:
print ("Failure")
elif c=='d':
for i,w in enumerate(self.ikWidgets):
if w.hasHighlight():
print ("Deleting IK widget")
#delete it
index = self.ikIndices[i]
self.widgetMaster.remove(w)
del self.ikWidgets[i]
del self.ikIndices[i]
del self.ikProblem.objectives[index]
for j in range(len(self.ikIndices)):
self.ikIndices[j] = j
self.refresh()
break
elif c=='t':
clicked = self.click_world(x,y)
if clicked is not None and isinstance(clicked[0],RobotModelLink):
#make a new widget
link, wpt = clicked
Tlink = link.getTransform()
self.ikIndices.append(len(self.ikWidgets))
self.ikWidgets.append(TransformPoser())
self.ikWidgets[-1].set(*Tlink)
self.widgetMaster.add(self.ikWidgets[-1])
self.ikProblem.addObjective(ik.objective(link,R=Tlink[0],t=Tlink[1]))
self.refresh()
elif c=='f':
self.ikdb.flush()
elif c=='s':
self.ikdb.save()
elif c=='b':
self.ikdb.backgroundStep()
self.refresh()
elif c=='B':
if hasattr(self.ikdb,'thread'):
self.ikdb.stopBackgroundLoop()
else:
self.ikdb.startBackgroundLoop(0)
elif c=='v':
self.drawDb = not self.drawDb
elif c=='c':
self.continuous = not self.continuous
elif c == 'o':
self.ikProblem.setSoftObjectives(not self.ikProblem.softObjectives)
def display(self):
if self.reSolve:
self.planningWorld.robot(0).setConfig(self.currentConfig)
soln = self.ikdb.solve(self.ikProblem)
if soln:
self.currentConfig = soln
self.reSolve = False
self.world.robot(0).setConfig(self.currentConfig)
GLWidgetProgram.display(self)
glDisable(GL_LIGHTING)
#draw IK goals
for obj in self.ikProblem.objectives:
linkindex = obj.link()
link = self.world.robot(0).link(linkindex)
lp,wpdes = obj.getPosition()
wp = se3.apply(link.getTransform(),lp)
glLineWidth(4.0)
glDisable(GL_LIGHTING)
glColor3f(0,1,0)
glBegin(GL_LINES)
glVertex3f(*wp)
glVertex3f(*wpdes)
glEnd()
glLineWidth(1)
#draw end positions of solved problems
if self.drawDb:
glPointSize(3.0)
glBegin(GL_POINTS)
for k,db in iteritems(self.ikdb.databases):
for i in range(db.numProblems()):
try:
p = db.getProblem(i)
except Exception as e:
traceback.print_exc()
exit(0)
if db.solutions[i] is None:
glColor3f(1,0,0)
else:
glColor3f(0,0,1)
for obj in p.objectives:
lp,wpdes = obj.getPosition()
glVertex3f(*wpdes)
glColor3f(1,1,0)
for pjson,soln in self.ikdb.backburner:
p = IKProblem()
p.fromJson(pjson)
for obj in p.objectives:
lp,wpdes = obj.getPosition()
glVertex3f(*wpdes)
glEnd()
return
def click_world(self,x,y):
"""Helper: returns (obj,pt) where obj is the closest world object
clicked, and pt is the associated clicked point (in world coordinates).
If no point is clicked, returns None."""
#get the viewport ray
if NEW_KLAMPT:
(s,d) =
|
__init__
|
identifier_name
|
ikdbtest_gl.py
|
PluginProgram):
def __init__(self,world,name):
GLPluginProgram.__init__(self,name)
self.widgetPlugin = GLWidgetPlugin()
self.setPlugin(self.widgetPlugin)
self.widgetMaster = self.widgetPlugin.klamptwidgetmaster
self.world = world
def display(self):
GLPluginProgram.display(self)
self.world.drawGL()
else:
NEW_KLAMPT = False
from klampt import ik,loader
from klampt.glrobotprogram import *
from klampt import PointPoser,TransformPoser
from klampt import robotcollide as collide
from klampt import se3
import sys
import traceback
import numpy as np
#preload
from sklearn.neighbors import NearestNeighbors,BallTree
class IKDBVisualTester(GLWidgetProgram):
def __init__(self,visWorld,planningWorld,name="IK Database visual tester"):
|
def mousefunc(self,button,state,x,y):
#Put your mouse handler here
#the current example prints out the list of objects clicked whenever
#you right click
GLWidgetProgram.mousefunc(self,button,state,x,y)
self.reSolve = False
dragging = False
if NEW_KLAMPT:
dragging = self.widgetPlugin.klamptwidgetdragging
else:
dragging = self.draggingWidget
if not dragging and button == 2 and state==0:
#down
clicked = self.click_world(x,y)
if clicked is not None and isinstance(clicked[0],RobotModelLink):
#make a new widget
link, wpt = clicked
lpt = se3.apply(se3.inv(link.getTransform()),wpt)
self.ikIndices.append(len(self.ikWidgets))
self.ikWidgets.append(PointPoser())
self.ikWidgets[-1].set(wpt)
self.widgetMaster.add(self.ikWidgets[-1])
self.ikProblem.addObjective(ik.objective(link,local=lpt,world=wpt))
GLWidgetProgram.mousefunc(self,button,state,x,y)
self.refresh()
return
#the dx,dy arguments are needed to be cross-compatible between 0.6.x and 0.7
def motionfunc(self,x,y,dx=0,dy=0):
dragging = False
if NEW_KLAMPT:
retval = GLWidgetProgram.motionfunc(self,x,y,dx,dy)
dragging = self.widgetPlugin.klamptwidgetdragging
else:
retval = GLWidgetProgram.motionfunc(self,x,y)
dragging = self.draggingWidget
if dragging:
#update all the IK objectives
for i in range(len(self.ikWidgets)):
index = self.ikIndices[i]
if isinstance(self.ikWidgets[i],PointPoser):
wptnew = self.ikWidgets[i].get()
obj = self.ikProblem.objectives[index]
link = obj.link()
lpt,wptold = obj.getPosition()
obj.setFixedPoint(link,lpt,wptnew)
#don't solve now, wait for refresh to process
if self.continuous and wptnew != wptold:
self.reSolve = True
elif isinstance(self.ikWidgets[i],TransformPoser):
Rnew,tnew = self.ikWidgets[i].get()
obj = self.ikProblem.objectives[index]
link = obj.link()
Rold,told = obj.getTransform()
obj.setFixedTransform(link,Rnew,tnew)
#don't solve now, wait for refresh to process
if self.continuous and (Rnew,tnew) != (Rold,told):
self.reSolve = True
return retval
def keyboardfunc(self,c,x,y):
if c=='h':
print ('HELP:')
print ('[right-click]: add a new IK constraint')
print ('[space]: tests the current configuration')
print ('d: deletes IK constraint')
print ('t: adds a new rotation-fixed IK constraint')
print ('f: flushes the current database to disk')
print ('s: saves the current database to disk')
print ('b: performs one background step')
print ('B: starts / stops the background thread')
print ('v: toggles display of the database')
print ('c: toggles continuous re-solving of IK constraint its as being moved')
print ('o: toggles soft / hard IK constraints')
elif c==' ':
self.planningWorld.robot(0).setConfig(self.currentConfig)
soln = self.ikdb.solve(self.ikProblem)
if soln:
print ("Solved")
self.currentConfig = soln
self.refresh()
else:
print ("Failure")
elif c=='d':
for i,w in enumerate(self.ikWidgets):
if w.hasHighlight():
print ("Deleting IK widget")
#delete it
index = self.ikIndices[i]
self.widgetMaster.remove(w)
del self.ikWidgets[i]
del self.ikIndices[i]
del self.ikProblem.objectives[index]
for j in range(len(self.ikIndices)):
self.ikIndices[j] = j
self.refresh()
break
elif c=='t':
clicked = self.click_world(x,y)
if clicked is not None and isinstance(clicked[0],RobotModelLink):
#make a new widget
link, wpt = clicked
Tlink = link.getTransform()
self.ikIndices.append(len(self.ikWidgets))
self.ikWidgets.append(TransformPoser())
self.ikWidgets[-1].set(*Tlink)
self.widgetMaster.add(self.ikWidgets[-1])
self.ikProblem.addObjective(ik.objective(link,R=Tlink[0],t=Tlink[1]))
self.refresh()
elif c=='f':
self.ikdb.flush()
elif c=='s':
self.ikdb.save()
elif c=='b':
self.ikdb.backgroundStep()
self.refresh()
elif c=='B':
if hasattr(self.ikdb,'thread'):
self.ikdb.stopBackgroundLoop()
else:
self.ikdb.startBackgroundLoop(0)
elif c=='v':
self.drawDb = not self.drawDb
elif c=='c':
self.continuous = not self.continuous
elif c == 'o':
self.ikProblem.setSoftObjectives(not self.ikProblem.softObjectives)
def display(self):
if self.reSolve:
self.planningWorld.robot(0).setConfig(self.currentConfig)
soln = self.ikdb.solve(self.ikProblem)
if soln:
self.currentConfig = soln
self.reSolve = False
self.world.robot(0).setConfig(self.currentConfig)
GLWidgetProgram.display(self)
glDisable(GL_LIGHTING)
#draw IK goals
for obj in self.ikProblem.objectives:
linkindex = obj.link()
link = self.world.robot(0).link(linkindex)
lp,wpdes = obj.getPosition()
wp = se3.apply(link.getTransform(),lp)
glLineWidth(4.0)
glDisable(GL_LIGHTING)
glColor3f(0,1,0)
glBegin(GL_LINES)
glVertex3f(*wp)
glVertex3f(*wpdes)
glEnd()
glLineWidth(1)
#draw end positions of solved problems
if self.drawDb:
glPointSize(3.0)
glBegin(GL_POINTS)
for k,db in iteritems(self.ikdb.databases):
for i in range(db.numProblems()):
try:
p = db.getProblem(i)
except Exception as e:
traceback.print_exc()
exit(0)
if db.solutions[i] is None:
glColor3f(1,0,0)
else:
glColor3f(0,0,1)
for obj in p.objectives:
lp,wpdes = obj.getPosition()
glVertex3f(*wpdes)
glColor3f(1,1,0)
for pjson,soln in self.ikdb.backburner:
p = IKProblem()
p.fromJson(pjson)
for obj in p.objectives:
lp,wpdes = obj.getPosition()
glVertex3f(*wpdes)
glEnd()
return
def click_world(self,x,y):
"""Helper: returns (obj,pt) where obj is the closest world object
clicked, and pt is the associated clicked point (in world coordinates).
If no point is clicked, returns None."""
#get the viewport ray
if NEW_KLAMPT:
(s,d) =
|
GLWidgetProgram.__init__(self,visWorld,name)
self.planningWorld = planningWorld
self.collider = collide.WorldCollider(visWorld)
self.ikdb = ManagedIKDatabase(planningWorld.robot(0))
self.ikWidgets = []
self.ikIndices = []
self.ikProblem = IKProblem()
self.ikProblem.setFeasibilityTest('collisionFree',None)
qmin,qmax = planningWorld.robot(0).getJointLimits()
self.ikProblem.setCostFunction('jointRangeCost_dynamic',[qmin,qmax])
self.drawDb = False
self.continuous = False
self.reSolve = False
self.currentConfig = self.world.robot(0).getConfig()
|
identifier_body
|
index.go
|
can
// only happen for line numbers; give it no line number (= 0)
x = 0
}
// encode kind: bits [1..4)
x |= SpotInfo(kind) << 1;
// encode isIndex: bit 0
if isIndex {
x |= 1
}
return x;
}
func (x SpotInfo) Kind() SpotKind { return SpotKind(x >> 1 & 7) }
func (x SpotInfo) Lori() int { return int(x >> 4) }
func (x SpotInfo) IsIndex() bool { return x&1 != 0 }
// ----------------------------------------------------------------------------
// KindRun
// Debugging support. Disable to see multiple entries per line.
const removeDuplicates = true
// A KindRun is a run of SpotInfos of the same kind in a given file.
type KindRun struct {
Kind SpotKind;
Infos []SpotInfo;
}
// KindRuns are sorted by line number or index. Since the isIndex bit
// is always the same for all infos in one list we can compare lori's.
func (f *KindRun) Len() int { return len(f.Infos) }
func (f *KindRun) Less(i, j int) bool { return f.Infos[i].Lori() < f.Infos[j].Lori() }
func (f *KindRun) Swap(i, j int) { f.Infos[i], f.Infos[j] = f.Infos[j], f.Infos[i] }
// FileRun contents are sorted by Kind for the reduction into KindRuns.
func lessKind(x, y interface{}) bool { return x.(SpotInfo).Kind() < y.(SpotInfo).Kind() }
// newKindRun allocates a new KindRun from the SpotInfo run [i, j) in h.
func newKindRun(h *RunList, i, j int) interface{} {
kind := h.At(i).(SpotInfo).Kind();
infos := make([]SpotInfo, j-i);
k := 0;
for ; i < j; i++ {
infos[k] = h.At(i).(SpotInfo);
k++;
}
run := &KindRun{kind, infos};
// Spots were sorted by file and kind to create this run.
// Within this run, sort them by line number or index.
sort.Sort(run);
if removeDuplicates {
// Since both the lori and kind field must be
// same for duplicates, and since the isIndex
// bit is always the same for all infos in one
// list we can simply compare the entire info.
k := 0;
var prev SpotInfo;
for i, x := range infos {
if x != prev || i == 0 {
infos[k] = x;
k++;
prev = x;
}
}
run.Infos = infos[0:k];
}
return run;
}
// ----------------------------------------------------------------------------
// FileRun
// A Pak describes a Go package.
type Pak struct {
Path string; // path of directory containing the package
Name string; // package name as declared by package clause
}
// Paks are sorted by name (primary key) and by import path (secondary key).
func (p *Pak) less(q *Pak) bool {
return p.Name < q.Name || p.Name == q.Name && p.Path < q.Path
}
// A File describes a Go file.
type File struct {
Path string; // complete file name
Pak Pak; // the package to which the file belongs
}
// A Spot describes a single occurence of a word.
type Spot struct {
File *File;
Info SpotInfo;
}
// A FileRun is a list of KindRuns belonging to the same file.
type FileRun struct {
File *File;
Groups []*KindRun;
}
// Spots are sorted by path for the reduction into FileRuns.
func lessSpot(x, y interface{}) bool { return x.(Spot).File.Path < y.(Spot).File.Path }
// newFileRun allocates a new FileRun from the Spot run [i, j) in h.
func newFileRun(h0 *RunList, i, j int) interface{} {
file := h0.At(i).(Spot).File;
// reduce the list of Spots into a list of KindRuns
var h1 RunList;
h1.Vector.Init(j - i);
k := 0;
for ; i < j; i++ {
h1.Set(k, h0.At(i).(Spot).Info);
k++;
}
h2 := h1.reduce(lessKind, newKindRun);
// create the FileRun
groups := make([]*KindRun, h2.Len());
for i := 0; i < h2.Len(); i++ {
groups[i] = h2.At(i).(*KindRun)
}
return &FileRun{file, groups};
}
// ----------------------------------------------------------------------------
// PakRun
// A PakRun describes a run of *FileRuns of a package.
type PakRun struct {
Pak Pak;
Files []*FileRun;
}
// Sorting support for files within a PakRun.
func (p *PakRun) Len() int { return len(p.Files) }
func (p *PakRun) Less(i, j int) bool { return p.Files[i].File.Path < p.Files[j].File.Path }
func (p *PakRun) Swap(i, j int) { p.Files[i], p.Files[j] = p.Files[j], p.Files[i] }
// FileRuns are sorted by package for the reduction into PakRuns.
func lessFileRun(x, y interface{}) bool {
return x.(*FileRun).File.Pak.less(&y.(*FileRun).File.Pak)
}
// newPakRun allocates a new PakRun from the *FileRun run [i, j) in h.
func newPakRun(h *RunList, i, j int) interface{} {
pak := h.At(i).(*FileRun).File.Pak;
files := make([]*FileRun, j-i);
k := 0;
for ; i < j; i++
|
run := &PakRun{pak, files};
sort.Sort(run); // files were sorted by package; sort them by file now
return run;
}
// ----------------------------------------------------------------------------
// HitList
// A HitList describes a list of PakRuns.
type HitList []*PakRun
// PakRuns are sorted by package.
func lessPakRun(x, y interface{}) bool { return x.(*PakRun).Pak.less(&y.(*PakRun).Pak) }
func reduce(h0 *RunList) HitList {
// reduce a list of Spots into a list of FileRuns
h1 := h0.reduce(lessSpot, newFileRun);
// reduce a list of FileRuns into a list of PakRuns
h2 := h1.reduce(lessFileRun, newPakRun);
// sort the list of PakRuns by package
h2.sort(lessPakRun);
// create a HitList
h := make(HitList, h2.Len());
for i := 0; i < h2.Len(); i++ {
h[i] = h2.At(i).(*PakRun)
}
return h;
}
func (h HitList) filter(pakname string) HitList {
// determine number of matching packages (most of the time just one)
n := 0;
for _, p := range h {
if p.Pak.Name == pakname {
n++
}
}
// create filtered HitList
hh := make(HitList, n);
i := 0;
for _, p := range h {
if p.Pak.Name == pakname {
hh[i] = p;
i++;
}
}
return hh;
}
// ----------------------------------------------------------------------------
// AltWords
type wordPair struct {
canon string; // canonical word spelling (all lowercase)
alt string; // alternative spelling
}
// An AltWords describes a list of alternative spellings for a
// canonical (all lowercase) spelling of a word.
type AltWords struct {
Canon string; // canonical word spelling (all lowercase)
Alts []string; // alternative spelling for the same word
}
// wordPairs are sorted by their canonical spelling.
func lessWordPair(x, y interface{}) bool { return x.(*wordPair).canon < y.(*wordPair).canon }
// newAltWords allocates a new AltWords from the *wordPair run [i, j) in h.
func newAltWords(h *RunList, i, j int) interface{} {
canon := h.At(i).(*wordPair).canon;
alts := make([]string, j-i);
k := 0;
for ; i < j; i++ {
alts[k] = h.At(i).(*wordPair).alt;
k++;
}
return &AltWords{canon, alts};
}
func (a *AltWords) filter(s string) *AltWords {
if len(a.Alts) == 1 && a.Alts[0] == s {
// there are no different alternatives
return nil
}
// make a new AltWords with the current spelling removed
alts := make([]string, len(a.Alts));
i := 0;
for _, w := range a.Alts {
|
{
files[k] = h.At(i).(*FileRun);
k++;
}
|
conditional_block
|
index.go
|
can
// only happen for line numbers; give it no line number (= 0)
x = 0
}
// encode kind: bits [1..4)
x |= SpotInfo(kind) << 1;
// encode isIndex: bit 0
if isIndex {
x |= 1
}
return x;
}
func (x SpotInfo) Kind() SpotKind
|
func (x SpotInfo) Lori() int { return int(x >> 4) }
func (x SpotInfo) IsIndex() bool { return x&1 != 0 }
// ----------------------------------------------------------------------------
// KindRun
// Debugging support. Disable to see multiple entries per line.
const removeDuplicates = true
// A KindRun is a run of SpotInfos of the same kind in a given file.
type KindRun struct {
Kind SpotKind;
Infos []SpotInfo;
}
// KindRuns are sorted by line number or index. Since the isIndex bit
// is always the same for all infos in one list we can compare lori's.
func (f *KindRun) Len() int { return len(f.Infos) }
func (f *KindRun) Less(i, j int) bool { return f.Infos[i].Lori() < f.Infos[j].Lori() }
func (f *KindRun) Swap(i, j int) { f.Infos[i], f.Infos[j] = f.Infos[j], f.Infos[i] }
// FileRun contents are sorted by Kind for the reduction into KindRuns.
func lessKind(x, y interface{}) bool { return x.(SpotInfo).Kind() < y.(SpotInfo).Kind() }
// newKindRun allocates a new KindRun from the SpotInfo run [i, j) in h.
func newKindRun(h *RunList, i, j int) interface{} {
kind := h.At(i).(SpotInfo).Kind();
infos := make([]SpotInfo, j-i);
k := 0;
for ; i < j; i++ {
infos[k] = h.At(i).(SpotInfo);
k++;
}
run := &KindRun{kind, infos};
// Spots were sorted by file and kind to create this run.
// Within this run, sort them by line number or index.
sort.Sort(run);
if removeDuplicates {
// Since both the lori and kind field must be
// same for duplicates, and since the isIndex
// bit is always the same for all infos in one
// list we can simply compare the entire info.
k := 0;
var prev SpotInfo;
for i, x := range infos {
if x != prev || i == 0 {
infos[k] = x;
k++;
prev = x;
}
}
run.Infos = infos[0:k];
}
return run;
}
// ----------------------------------------------------------------------------
// FileRun
// A Pak describes a Go package.
type Pak struct {
Path string; // path of directory containing the package
Name string; // package name as declared by package clause
}
// Paks are sorted by name (primary key) and by import path (secondary key).
func (p *Pak) less(q *Pak) bool {
return p.Name < q.Name || p.Name == q.Name && p.Path < q.Path
}
// A File describes a Go file.
type File struct {
Path string; // complete file name
Pak Pak; // the package to which the file belongs
}
// A Spot describes a single occurence of a word.
type Spot struct {
File *File;
Info SpotInfo;
}
// A FileRun is a list of KindRuns belonging to the same file.
type FileRun struct {
File *File;
Groups []*KindRun;
}
// Spots are sorted by path for the reduction into FileRuns.
func lessSpot(x, y interface{}) bool { return x.(Spot).File.Path < y.(Spot).File.Path }
// newFileRun allocates a new FileRun from the Spot run [i, j) in h.
func newFileRun(h0 *RunList, i, j int) interface{} {
file := h0.At(i).(Spot).File;
// reduce the list of Spots into a list of KindRuns
var h1 RunList;
h1.Vector.Init(j - i);
k := 0;
for ; i < j; i++ {
h1.Set(k, h0.At(i).(Spot).Info);
k++;
}
h2 := h1.reduce(lessKind, newKindRun);
// create the FileRun
groups := make([]*KindRun, h2.Len());
for i := 0; i < h2.Len(); i++ {
groups[i] = h2.At(i).(*KindRun)
}
return &FileRun{file, groups};
}
// ----------------------------------------------------------------------------
// PakRun
// A PakRun describes a run of *FileRuns of a package.
type PakRun struct {
Pak Pak;
Files []*FileRun;
}
// Sorting support for files within a PakRun.
func (p *PakRun) Len() int { return len(p.Files) }
func (p *PakRun) Less(i, j int) bool { return p.Files[i].File.Path < p.Files[j].File.Path }
func (p *PakRun) Swap(i, j int) { p.Files[i], p.Files[j] = p.Files[j], p.Files[i] }
// FileRuns are sorted by package for the reduction into PakRuns.
func lessFileRun(x, y interface{}) bool {
return x.(*FileRun).File.Pak.less(&y.(*FileRun).File.Pak)
}
// newPakRun allocates a new PakRun from the *FileRun run [i, j) in h.
func newPakRun(h *RunList, i, j int) interface{} {
pak := h.At(i).(*FileRun).File.Pak;
files := make([]*FileRun, j-i);
k := 0;
for ; i < j; i++ {
files[k] = h.At(i).(*FileRun);
k++;
}
run := &PakRun{pak, files};
sort.Sort(run); // files were sorted by package; sort them by file now
return run;
}
// ----------------------------------------------------------------------------
// HitList
// A HitList describes a list of PakRuns.
type HitList []*PakRun
// PakRuns are sorted by package.
func lessPakRun(x, y interface{}) bool { return x.(*PakRun).Pak.less(&y.(*PakRun).Pak) }
func reduce(h0 *RunList) HitList {
// reduce a list of Spots into a list of FileRuns
h1 := h0.reduce(lessSpot, newFileRun);
// reduce a list of FileRuns into a list of PakRuns
h2 := h1.reduce(lessFileRun, newPakRun);
// sort the list of PakRuns by package
h2.sort(lessPakRun);
// create a HitList
h := make(HitList, h2.Len());
for i := 0; i < h2.Len(); i++ {
h[i] = h2.At(i).(*PakRun)
}
return h;
}
func (h HitList) filter(pakname string) HitList {
// determine number of matching packages (most of the time just one)
n := 0;
for _, p := range h {
if p.Pak.Name == pakname {
n++
}
}
// create filtered HitList
hh := make(HitList, n);
i := 0;
for _, p := range h {
if p.Pak.Name == pakname {
hh[i] = p;
i++;
}
}
return hh;
}
// ----------------------------------------------------------------------------
// AltWords
type wordPair struct {
canon string; // canonical word spelling (all lowercase)
alt string; // alternative spelling
}
// An AltWords describes a list of alternative spellings for a
// canonical (all lowercase) spelling of a word.
type AltWords struct {
Canon string; // canonical word spelling (all lowercase)
Alts []string; // alternative spelling for the same word
}
// wordPairs are sorted by their canonical spelling.
func lessWordPair(x, y interface{}) bool { return x.(*wordPair).canon < y.(*wordPair).canon }
// newAltWords allocates a new AltWords from the *wordPair run [i, j) in h.
func newAltWords(h *RunList, i, j int) interface{} {
canon := h.At(i).(*wordPair).canon;
alts := make([]string, j-i);
k := 0;
for ; i < j; i++ {
alts[k] = h.At(i).(*wordPair).alt;
k++;
}
return &AltWords{canon, alts};
}
func (a *AltWords) filter(s string) *AltWords {
if len(a.Alts) == 1 && a.Alts[0] == s {
// there are no different alternatives
return nil
}
// make a new AltWords with the current spelling removed
alts := make([]string, len(a.Alts));
i := 0;
for _, w := range a.Alts {
if
|
{ return SpotKind(x >> 1 & 7) }
|
identifier_body
|
index.go
|
// ----------------------------------------------------------------------------
// RunList
// A RunList is a vector of entries that can be sorted according to some
// criteria. A RunList may be compressed by grouping "runs" of entries
// which are equal (according to the sort critera) into a new RunList of
// runs. For instance, a RunList containing pairs (x, y) may be compressed
// into a RunList containing pair runs (x, {y}) where each run consists of
// a list of y's with the same x.
type RunList struct {
vector.Vector;
less func(x, y interface{}) bool;
}
func (h *RunList) Less(i, j int) bool { return h.less(h.At(i), h.At(j)) }
func (h *RunList) sort(less func(x, y interface{}) bool) {
h.less = less;
sort.Sort(h);
}
// Compress entries which are the same according to a sort criteria
// (specified by less) into "runs".
func (h *RunList) reduce(less func(x, y interface{}) bool, newRun func(h *RunList, i, j int) interface{}) *RunList {
// create runs of entries with equal values
h.sort(less);
// for each run, make a new run object and collect them in a new RunList
var hh RunList;
i := 0;
for j := 0; j < h.Len(); j++ {
if less(h.At(i), h.At(j)) {
hh.Push(newRun(h, i, j));
i = j; // start a new run
}
}
// add final run, if any
if i < h.Len() {
hh.Push(newRun(h, i, h.Len()))
}
return &hh;
}
// ----------------------------------------------------------------------------
// SpotInfo
// A SpotInfo value describes a particular identifier spot in a given file;
// It encodes three values: the SpotKind (declaration or use), a line or
// snippet index "lori", and whether it's a line or index.
//
// The following encoding is used:
//
// bits 32 4 1 0
// value [lori|kind|isIndex]
//
type SpotInfo uint32
// SpotKind describes whether an identifier is declared (and what kind of
// declaration) or used.
type SpotKind uint32
const (
PackageClause SpotKind = iota;
ImportDecl;
ConstDecl;
TypeDecl;
VarDecl;
FuncDecl;
MethodDecl;
Use;
nKinds;
)
func init() {
// sanity check: if nKinds is too large, the SpotInfo
// accessor functions may need to be updated
if nKinds > 8 {
panic()
}
}
// makeSpotInfo makes a SpotInfo.
func makeSpotInfo(kind SpotKind, lori int, isIndex bool) SpotInfo {
// encode lori: bits [4..32)
x := SpotInfo(lori) << 4;
if int(x>>4) != lori {
// lori value doesn't fit - since snippet indices are
// most certainly always smaller then 1<<28, this can
// only happen for line numbers; give it no line number (= 0)
x = 0
}
// encode kind: bits [1..4)
x |= SpotInfo(kind) << 1;
// encode isIndex: bit 0
if isIndex {
x |= 1
}
return x;
}
func (x SpotInfo) Kind() SpotKind { return SpotKind(x >> 1 & 7) }
func (x SpotInfo) Lori() int { return int(x >> 4) }
func (x SpotInfo) IsIndex() bool { return x&1 != 0 }
// ----------------------------------------------------------------------------
// KindRun
// Debugging support. Disable to see multiple entries per line.
const removeDuplicates = true
// A KindRun is a run of SpotInfos of the same kind in a given file.
type KindRun struct {
Kind SpotKind;
Infos []SpotInfo;
}
// KindRuns are sorted by line number or index. Since the isIndex bit
// is always the same for all infos in one list we can compare lori's.
func (f *KindRun) Len() int { return len(f.Infos) }
func (f *KindRun) Less(i, j int) bool { return f.Infos[i].Lori() < f.Infos[j].Lori() }
func (f *KindRun) Swap(i, j int) { f.Infos[i], f.Infos[j] = f.Infos[j], f.Infos[i] }
// FileRun contents are sorted by Kind for the reduction into KindRuns.
func lessKind(x, y interface{}) bool { return x.(SpotInfo).Kind() < y.(SpotInfo).Kind() }
// newKindRun allocates a new KindRun from the SpotInfo run [i, j) in h.
func newKindRun(h *RunList, i, j int) interface{} {
kind := h.At(i).(SpotInfo).Kind();
infos := make([]SpotInfo, j-i);
k := 0;
for ; i < j; i++ {
infos[k] = h.At(i).(SpotInfo);
k++;
}
run := &KindRun{kind, infos};
// Spots were sorted by file and kind to create this run.
// Within this run, sort them by line number or index.
sort.Sort(run);
if removeDuplicates {
// Since both the lori and kind field must be
// same for duplicates, and since the isIndex
// bit is always the same for all infos in one
// list we can simply compare the entire info.
k := 0;
var prev SpotInfo;
for i, x := range infos {
if x != prev || i == 0 {
infos[k] = x;
k++;
prev = x;
}
}
run.Infos = infos[0:k];
}
return run;
}
// ----------------------------------------------------------------------------
// FileRun
// A Pak describes a Go package.
type Pak struct {
Path string; // path of directory containing the package
Name string; // package name as declared by package clause
}
// Paks are sorted by name (primary key) and by import path (secondary key).
func (p *Pak) less(q *Pak) bool {
return p.Name < q.Name || p.Name == q.Name && p.Path < q.Path
}
// A File describes a Go file.
type File struct {
Path string; // complete file name
Pak Pak; // the package to which the file belongs
}
// A Spot describes a single occurence of a word.
type Spot struct {
File *File;
Info SpotInfo;
}
// A FileRun is a list of KindRuns belonging to the same file.
type FileRun struct {
File *File;
Groups []*KindRun;
}
// Spots are sorted by path for the reduction into FileRuns.
func lessSpot(x, y interface{}) bool { return x.(Spot).File.Path < y.(Spot).File.Path }
// newFileRun allocates a new FileRun from the Spot run [i, j) in h.
func newFileRun(h0 *RunList, i, j int) interface{} {
file := h0.At(i).(Spot).File;
// reduce the list of Spots into a list of KindRuns
var h1 RunList;
h1.Vector.Init(j - i);
k := 0;
for ; i < j; i++ {
h1.Set(k, h0.At(i).(Spot).Info);
k++;
}
h2 := h1.reduce(lessKind, newKindRun);
// create the FileRun
groups := make([]*KindRun, h2.Len());
for i := 0; i < h2.Len(); i++ {
groups[i] = h2.At(i).(*KindRun)
}
return &FileRun{file, groups};
}
// ----------------------------------------------------------------------------
// PakRun
// A PakRun describes a run of *FileRuns of a package.
type PakRun struct {
Pak Pak;
Files []*FileRun;
}
// Sorting support for files within a PakRun.
func (p *PakRun) Len() int { return len(p.Files) }
func (p *PakRun) Less(i, j int) bool { return p.Files[i].File.Path < p.Files[j].File.Path }
func (p *PakRun) Swap(i, j int) { p.Files[i], p.Files[j] = p.Files[j], p.Files[i] }
// FileRuns are sorted by package for the reduction into PakRuns.
func lessFileRun(x, y interface{}) bool {
return x.(*FileRun).File.Pak.less(&y.(*FileRun).File.Pak)
}
// newPakRun allocates a new PakRun from the *FileRun run [i, j) in h.
func newPakRun(h *RunList, i, j int) interface{} {
pak := h.At(i).(*FileRun).File.Pak;
files := make([]*FileRun, j-i);
k := 0;
for ; i < j; i++ {
files[k] = h.At(i).(*FileRun);
k++;
}
run := &PakRun{
|
)
|
random_line_split
|
|
index.go
|
can
// only happen for line numbers; give it no line number (= 0)
x = 0
}
// encode kind: bits [1..4)
x |= SpotInfo(kind) << 1;
// encode isIndex: bit 0
if isIndex {
x |= 1
}
return x;
}
func (x SpotInfo) Kind() SpotKind { return SpotKind(x >> 1 & 7) }
func (x SpotInfo) Lori() int { return int(x >> 4) }
func (x SpotInfo) IsIndex() bool { return x&1 != 0 }
// ----------------------------------------------------------------------------
// KindRun
// Debugging support. Disable to see multiple entries per line.
const removeDuplicates = true
// A KindRun is a run of SpotInfos of the same kind in a given file.
type KindRun struct {
Kind SpotKind;
Infos []SpotInfo;
}
// KindRuns are sorted by line number or index. Since the isIndex bit
// is always the same for all infos in one list we can compare lori's.
func (f *KindRun) Len() int { return len(f.Infos) }
func (f *KindRun) Less(i, j int) bool { return f.Infos[i].Lori() < f.Infos[j].Lori() }
func (f *KindRun) Swap(i, j int) { f.Infos[i], f.Infos[j] = f.Infos[j], f.Infos[i] }
// FileRun contents are sorted by Kind for the reduction into KindRuns.
func lessKind(x, y interface{}) bool { return x.(SpotInfo).Kind() < y.(SpotInfo).Kind() }
// newKindRun allocates a new KindRun from the SpotInfo run [i, j) in h.
func newKindRun(h *RunList, i, j int) interface{} {
kind := h.At(i).(SpotInfo).Kind();
infos := make([]SpotInfo, j-i);
k := 0;
for ; i < j; i++ {
infos[k] = h.At(i).(SpotInfo);
k++;
}
run := &KindRun{kind, infos};
// Spots were sorted by file and kind to create this run.
// Within this run, sort them by line number or index.
sort.Sort(run);
if removeDuplicates {
// Since both the lori and kind field must be
// same for duplicates, and since the isIndex
// bit is always the same for all infos in one
// list we can simply compare the entire info.
k := 0;
var prev SpotInfo;
for i, x := range infos {
if x != prev || i == 0 {
infos[k] = x;
k++;
prev = x;
}
}
run.Infos = infos[0:k];
}
return run;
}
// ----------------------------------------------------------------------------
// FileRun
// A Pak describes a Go package.
type Pak struct {
Path string; // path of directory containing the package
Name string; // package name as declared by package clause
}
// Paks are sorted by name (primary key) and by import path (secondary key).
func (p *Pak) less(q *Pak) bool {
return p.Name < q.Name || p.Name == q.Name && p.Path < q.Path
}
// A File describes a Go file.
type File struct {
Path string; // complete file name
Pak Pak; // the package to which the file belongs
}
// A Spot describes a single occurence of a word.
type Spot struct {
File *File;
Info SpotInfo;
}
// A FileRun is a list of KindRuns belonging to the same file.
type FileRun struct {
File *File;
Groups []*KindRun;
}
// Spots are sorted by path for the reduction into FileRuns.
func lessSpot(x, y interface{}) bool { return x.(Spot).File.Path < y.(Spot).File.Path }
// newFileRun allocates a new FileRun from the Spot run [i, j) in h.
func newFileRun(h0 *RunList, i, j int) interface{} {
file := h0.At(i).(Spot).File;
// reduce the list of Spots into a list of KindRuns
var h1 RunList;
h1.Vector.Init(j - i);
k := 0;
for ; i < j; i++ {
h1.Set(k, h0.At(i).(Spot).Info);
k++;
}
h2 := h1.reduce(lessKind, newKindRun);
// create the FileRun
groups := make([]*KindRun, h2.Len());
for i := 0; i < h2.Len(); i++ {
groups[i] = h2.At(i).(*KindRun)
}
return &FileRun{file, groups};
}
// ----------------------------------------------------------------------------
// PakRun
// A PakRun describes a run of *FileRuns of a package.
type PakRun struct {
Pak Pak;
Files []*FileRun;
}
// Sorting support for files within a PakRun.
func (p *PakRun) Len() int { return len(p.Files) }
func (p *PakRun) Less(i, j int) bool { return p.Files[i].File.Path < p.Files[j].File.Path }
func (p *PakRun) Swap(i, j int) { p.Files[i], p.Files[j] = p.Files[j], p.Files[i] }
// FileRuns are sorted by package for the reduction into PakRuns.
func lessFileRun(x, y interface{}) bool {
return x.(*FileRun).File.Pak.less(&y.(*FileRun).File.Pak)
}
// newPakRun allocates a new PakRun from the *FileRun run [i, j) in h.
func newPakRun(h *RunList, i, j int) interface{} {
pak := h.At(i).(*FileRun).File.Pak;
files := make([]*FileRun, j-i);
k := 0;
for ; i < j; i++ {
files[k] = h.At(i).(*FileRun);
k++;
}
run := &PakRun{pak, files};
sort.Sort(run); // files were sorted by package; sort them by file now
return run;
}
// ----------------------------------------------------------------------------
// HitList
// A HitList describes a list of PakRuns.
type HitList []*PakRun
// PakRuns are sorted by package.
func lessPakRun(x, y interface{}) bool { return x.(*PakRun).Pak.less(&y.(*PakRun).Pak) }
func reduce(h0 *RunList) HitList {
// reduce a list of Spots into a list of FileRuns
h1 := h0.reduce(lessSpot, newFileRun);
// reduce a list of FileRuns into a list of PakRuns
h2 := h1.reduce(lessFileRun, newPakRun);
// sort the list of PakRuns by package
h2.sort(lessPakRun);
// create a HitList
h := make(HitList, h2.Len());
for i := 0; i < h2.Len(); i++ {
h[i] = h2.At(i).(*PakRun)
}
return h;
}
func (h HitList) filter(pakname string) HitList {
// determine number of matching packages (most of the time just one)
n := 0;
for _, p := range h {
if p.Pak.Name == pakname {
n++
}
}
// create filtered HitList
hh := make(HitList, n);
i := 0;
for _, p := range h {
if p.Pak.Name == pakname {
hh[i] = p;
i++;
}
}
return hh;
}
// ----------------------------------------------------------------------------
// AltWords
type wordPair struct {
canon string; // canonical word spelling (all lowercase)
alt string; // alternative spelling
}
// An AltWords describes a list of alternative spellings for a
// canonical (all lowercase) spelling of a word.
type AltWords struct {
Canon string; // canonical word spelling (all lowercase)
Alts []string; // alternative spelling for the same word
}
// wordPairs are sorted by their canonical spelling.
func lessWordPair(x, y interface{}) bool { return x.(*wordPair).canon < y.(*wordPair).canon }
// newAltWords allocates a new AltWords from the *wordPair run [i, j) in h.
func newAltWords(h *RunList, i, j int) interface{} {
canon := h.At(i).(*wordPair).canon;
alts := make([]string, j-i);
k := 0;
for ; i < j; i++ {
alts[k] = h.At(i).(*wordPair).alt;
k++;
}
return &AltWords{canon, alts};
}
func (a *AltWords)
|
(s string) *AltWords {
if len(a.Alts) == 1 && a.Alts[0] == s {
// there are no different alternatives
return nil
}
// make a new AltWords with the current spelling removed
alts := make([]string, len(a.Alts));
i := 0;
for _, w := range a.Alts {
if
|
filter
|
identifier_name
|
allocator.rs
|
is an assumption that each worker performs the same channel allocation logic; things go wrong otherwise.
pub trait Communicator: 'static {
fn index(&self) -> u64; // number out of peers
fn peers(&self) -> u64; // number of peers
fn new_channel<T:Send+Columnar+Any>(&mut self) -> (Vec<Box<Pushable<T>>>, Box<Pullable<T>>);
}
// TODO : Would be nice if Communicator had associated types for its Pushable and Pullable types,
// TODO : but they would have to be generic over T, with the current set-up. Might require HKT?
// impl<'a, C: Communicator + 'a> Communicator for &'a mut C {
// fn index(&self) -> u64 { (**self).index() }
// fn peers(&self) -> u64 { (**self).peers() }
// fn new_channel<T:Send+Columnar+Any>(&mut self) -> (Vec<Box<Pushable<T>>>, Box<Pullable<T>>) { (**self).new_channel() }
// }
// The simplest communicator remains worker-local and just queues sent messages.
pub struct ThreadCommunicator;
impl Communicator for ThreadCommunicator {
fn index(&self) -> u64 { 0 }
fn
|
(&self) -> u64 { 1 }
fn new_channel<T:'static>(&mut self) -> (Vec<Box<Pushable<T>>>, Box<Pullable<T>>) {
let shared = Rc::new(RefCell::new(VecDeque::<T>::new()));
return (vec![Box::new(shared.clone()) as Box<Pushable<T>>], Box::new(shared.clone()) as Box<Pullable<T>>)
}
}
// A specific Communicator for inter-thread intra-process communication
pub struct ProcessCommunicator {
inner: ThreadCommunicator, // inner ThreadCommunicator
index: u64, // number out of peers
peers: u64, // number of peer allocators (for typed channel allocation).
allocated: u64, // indicates how many have been allocated (locally).
channels: Arc<Mutex<Vec<Box<Any+Send>>>>, // Box<Any+Send> -> Box<Vec<Option<(Vec<Sender<T>>, Receiver<T>)>>>
}
impl ProcessCommunicator {
pub fn inner<'a>(&'a mut self) -> &'a mut ThreadCommunicator { &mut self.inner }
pub fn new_vector(count: u64) -> Vec<ProcessCommunicator> {
let channels = Arc::new(Mutex::new(Vec::new()));
return (0 .. count).map(|index| ProcessCommunicator {
inner: ThreadCommunicator,
index: index,
peers: count,
allocated: 0,
channels: channels.clone(),
}).collect();
}
}
impl Communicator for ProcessCommunicator {
fn index(&self) -> u64 { self.index }
fn peers(&self) -> u64 { self.peers }
fn new_channel<T:Send+Any>(&mut self) -> (Vec<Box<Pushable<T>>>, Box<Pullable<T>>) {
let mut channels = self.channels.lock().ok().expect("mutex error?");
if self.allocated == channels.len() as u64 { // we need a new channel ...
let mut senders = Vec::new();
let mut receivers = Vec::new();
for _ in (0..self.peers) {
let (s, r): (Sender<T>, Receiver<T>) = channel();
senders.push(s);
receivers.push(r);
}
let mut to_box = Vec::new();
for recv in receivers.drain_temp() {
to_box.push(Some((senders.clone(), recv)));
}
channels.push(Box::new(to_box));
}
match channels[self.allocated as usize].downcast_mut::<(Vec<Option<(Vec<Sender<T>>, Receiver<T>)>>)>() {
Some(ref mut vector) => {
self.allocated += 1;
let (mut send, recv) = vector[self.index as usize].take().unwrap();
let mut temp = Vec::new();
for s in send.drain_temp() { temp.push(Box::new(s) as Box<Pushable<T>>); }
return (temp, Box::new(recv) as Box<Pullable<T>>)
}
_ => { panic!("unable to cast channel correctly"); }
}
}
}
// A communicator intended for binary channels (networking, pipes, shared memory)
pub struct BinaryCommunicator {
pub inner: ProcessCommunicator, // inner ProcessCommunicator (use for process-local channels)
pub index: u64, // index of this worker
pub peers: u64, // number of peer workers
pub graph: u64, // identifier for the current graph
pub allocated: u64, // indicates how many channels have been allocated (locally).
// for loading up state in the networking threads.
pub writers: Vec<Sender<((u64, u64, u64), Sender<Vec<u8>>)>>, // (index, back-to-worker)
pub readers: Vec<Sender<((u64, u64, u64), Sender<Vec<u8>>, Receiver<Vec<u8>>)>>, // (index, data-to-worker, back-from-worker)
pub senders: Vec<Sender<(MessageHeader, Vec<u8>)>> // for sending bytes!
}
impl BinaryCommunicator {
pub fn inner<'a>(&'a mut self) -> &'a mut ProcessCommunicator { &mut self.inner }
}
// A Communicator backed by Sender<Vec<u8>>/Receiver<Vec<u8>> pairs (e.g. networking, shared memory, files, pipes)
impl Communicator for BinaryCommunicator {
fn index(&self) -> u64 { self.index }
fn peers(&self) -> u64 { self.peers }
fn new_channel<T:Send+Columnar+Any>(&mut self) -> (Vec<Box<Pushable<T>>>, Box<Pullable<T>>) {
let mut pushers: Vec<Box<Pushable<T>>> = Vec::new(); // built-up vector of Box<Pushable<T>> to return
// we'll need process-local channels as well (no self-loop binary connection in this design; perhaps should allow)
let inner_peers = self.inner.peers();
let (inner_sends, inner_recv) = self.inner.new_channel();
// prep a pushable for each endpoint, multiplied by inner_peers
for (index, writer) in self.writers.iter().enumerate() {
for _ in (0..inner_peers) {
let (s,r) = channel(); // generate a binary (Vec<u8>) channel pair of (back_to_worker, back_from_net)
let target_index = if index as u64 >= (self.index * inner_peers) { index as u64 + inner_peers } else { index as u64 };
println!("init'ing send channel: ({} {} {})", self.index, self.graph, self.allocated);
writer.send(((self.index, self.graph, self.allocated), s)).unwrap();
let header = MessageHeader {
graph: self.graph,
channel: self.allocated,
source: self.index,
target: target_index,
length: 0,
};
pushers.push(Box::new(BinaryPushable::new(header, self.senders[index].clone(), r)));
}
}
// splice inner_sends into the vector of pushables
for (index, writer) in inner_sends.into_iter().enumerate() {
pushers.insert((self.index * inner_peers) as usize + index, writer);
}
// prep a Box<Pullable<T>> using inner_recv and fresh registered pullables
let (send,recv) = channel(); // binary channel from binary listener to BinaryPullable<T>
let mut pullsends = Vec::new();
for reader in self.readers.iter() {
let (s,r) = channel();
pullsends.push(s);
println!("init'ing recv channel: ({} {} {})", self.index, self.graph, self.allocated);
reader.send(((self.index, self.graph, self.allocated), send.clone(), r)).unwrap();
}
let pullable = Box::new(BinaryPullable {
inner: inner_recv,
senders: pullsends,
receiver: recv,
stack: Default::default(),
});
self.allocated += 1;
return (pushers, pullable);
}
}
struct BinaryPushable<T: Columnar> {
header: MessageHeader,
sender: Sender<(MessageHeader, Vec<u8>)>, // targets for each remote destination
receiver: Receiver<Vec<u8>>, // source of empty binary vectors
phantom: PhantomData<T>,
buffer: Vec<u8>,
stack: <T as Columnar>::Stack,
}
impl<T: Columnar> BinaryPushable<T> {
pub fn new(header: MessageHeader, sender: Sender<(MessageHeader, Vec<u8>)>, receiver: Receiver<Vec<u8>>) -> BinaryPushable<T> {
BinaryPushable {
header: header,
sender: sender,
receiver: receiver,
phantom:
|
peers
|
identifier_name
|
allocator.rs
|
pub trait Communicator: 'static {
fn index(&self) -> u64; // number out of peers
fn peers(&self) -> u64; // number of peers
fn new_channel<T:Send+Columnar+Any>(&mut self) -> (Vec<Box<Pushable<T>>>, Box<Pullable<T>>);
}
// TODO : Would be nice if Communicator had associated types for its Pushable and Pullable types,
// TODO : but they would have to be generic over T, with the current set-up. Might require HKT?
// impl<'a, C: Communicator + 'a> Communicator for &'a mut C {
// fn index(&self) -> u64 { (**self).index() }
// fn peers(&self) -> u64 { (**self).peers() }
// fn new_channel<T:Send+Columnar+Any>(&mut self) -> (Vec<Box<Pushable<T>>>, Box<Pullable<T>>) { (**self).new_channel() }
// }
// The simplest communicator remains worker-local and just queues sent messages.
pub struct ThreadCommunicator;
impl Communicator for ThreadCommunicator {
fn index(&self) -> u64 { 0 }
fn peers(&self) -> u64 { 1 }
fn new_channel<T:'static>(&mut self) -> (Vec<Box<Pushable<T>>>, Box<Pullable<T>>) {
let shared = Rc::new(RefCell::new(VecDeque::<T>::new()));
return (vec![Box::new(shared.clone()) as Box<Pushable<T>>], Box::new(shared.clone()) as Box<Pullable<T>>)
}
}
// A specific Communicator for inter-thread intra-process communication
pub struct ProcessCommunicator {
inner: ThreadCommunicator, // inner ThreadCommunicator
index: u64, // number out of peers
peers: u64, // number of peer allocators (for typed channel allocation).
allocated: u64, // indicates how many have been allocated (locally).
channels: Arc<Mutex<Vec<Box<Any+Send>>>>, // Box<Any+Send> -> Box<Vec<Option<(Vec<Sender<T>>, Receiver<T>)>>>
}
impl ProcessCommunicator {
pub fn inner<'a>(&'a mut self) -> &'a mut ThreadCommunicator { &mut self.inner }
pub fn new_vector(count: u64) -> Vec<ProcessCommunicator> {
let channels = Arc::new(Mutex::new(Vec::new()));
return (0 .. count).map(|index| ProcessCommunicator {
inner: ThreadCommunicator,
index: index,
peers: count,
allocated: 0,
channels: channels.clone(),
}).collect();
}
}
impl Communicator for ProcessCommunicator {
fn index(&self) -> u64 { self.index }
fn peers(&self) -> u64 { self.peers }
fn new_channel<T:Send+Any>(&mut self) -> (Vec<Box<Pushable<T>>>, Box<Pullable<T>>) {
let mut channels = self.channels.lock().ok().expect("mutex error?");
if self.allocated == channels.len() as u64 { // we need a new channel ...
let mut senders = Vec::new();
let mut receivers = Vec::new();
for _ in (0..self.peers) {
let (s, r): (Sender<T>, Receiver<T>) = channel();
senders.push(s);
receivers.push(r);
}
let mut to_box = Vec::new();
for recv in receivers.drain_temp() {
to_box.push(Some((senders.clone(), recv)));
}
channels.push(Box::new(to_box));
}
match channels[self.allocated as usize].downcast_mut::<(Vec<Option<(Vec<Sender<T>>, Receiver<T>)>>)>() {
Some(ref mut vector) => {
self.allocated += 1;
let (mut send, recv) = vector[self.index as usize].take().unwrap();
let mut temp = Vec::new();
for s in send.drain_temp() { temp.push(Box::new(s) as Box<Pushable<T>>); }
return (temp, Box::new(recv) as Box<Pullable<T>>)
}
_ => { panic!("unable to cast channel correctly"); }
}
}
}
// A communicator intended for binary channels (networking, pipes, shared memory)
pub struct BinaryCommunicator {
pub inner: ProcessCommunicator, // inner ProcessCommunicator (use for process-local channels)
pub index: u64, // index of this worker
pub peers: u64, // number of peer workers
pub graph: u64, // identifier for the current graph
pub allocated: u64, // indicates how many channels have been allocated (locally).
// for loading up state in the networking threads.
pub writers: Vec<Sender<((u64, u64, u64), Sender<Vec<u8>>)>>, // (index, back-to-worker)
pub readers: Vec<Sender<((u64, u64, u64), Sender<Vec<u8>>, Receiver<Vec<u8>>)>>, // (index, data-to-worker, back-from-worker)
pub senders: Vec<Sender<(MessageHeader, Vec<u8>)>> // for sending bytes!
}
impl BinaryCommunicator {
pub fn inner<'a>(&'a mut self) -> &'a mut ProcessCommunicator { &mut self.inner }
}
// A Communicator backed by Sender<Vec<u8>>/Receiver<Vec<u8>> pairs (e.g. networking, shared memory, files, pipes)
impl Communicator for BinaryCommunicator {
fn index(&self) -> u64 { self.index }
fn peers(&self) -> u64 { self.peers }
fn new_channel<T:Send+Columnar+Any>(&mut self) -> (Vec<Box<Pushable<T>>>, Box<Pullable<T>>) {
let mut pushers: Vec<Box<Pushable<T>>> = Vec::new(); // built-up vector of Box<Pushable<T>> to return
// we'll need process-local channels as well (no self-loop binary connection in this design; perhaps should allow)
let inner_peers = self.inner.peers();
let (inner_sends, inner_recv) = self.inner.new_channel();
// prep a pushable for each endpoint, multiplied by inner_peers
for (index, writer) in self.writers.iter().enumerate() {
for _ in (0..inner_peers) {
let (s,r) = channel(); // generate a binary (Vec<u8>) channel pair of (back_to_worker, back_from_net)
let target_index = if index as u64 >= (self.index * inner_peers) { index as u64 + inner_peers } else { index as u64 };
println!("init'ing send channel: ({} {} {})", self.index, self.graph, self.allocated);
writer.send(((self.index, self.graph, self.allocated), s)).unwrap();
let header = MessageHeader {
graph: self.graph,
channel: self.allocated,
source: self.index,
target: target_index,
length: 0,
};
pushers.push(Box::new(BinaryPushable::new(header, self.senders[index].clone(), r)));
}
}
// splice inner_sends into the vector of pushables
for (index, writer) in inner_sends.into_iter().enumerate() {
pushers.insert((self.index * inner_peers) as usize + index, writer);
}
// prep a Box<Pullable<T>> using inner_recv and fresh registered pullables
let (send,recv) = channel(); // binary channel from binary listener to BinaryPullable<T>
let mut pullsends = Vec::new();
for reader in self.readers.iter() {
let (s,r) = channel();
pullsends.push(s);
println!("init'ing recv channel: ({} {} {})", self.index, self.graph, self.allocated);
reader.send(((self.index, self.graph, self.allocated), send.clone(), r)).unwrap();
}
let pullable = Box::new(BinaryPullable {
inner: inner_recv,
senders: pullsends,
receiver: recv,
stack: Default::default(),
});
self.allocated += 1;
return (pushers, pullable);
}
}
struct BinaryPushable<T: Columnar> {
header: MessageHeader,
sender: Sender<(MessageHeader, Vec<u8>)>, // targets for each remote destination
receiver: Receiver<Vec<u8>>, // source of empty binary vectors
phantom: PhantomData<T>,
buffer: Vec<u8>,
stack: <T as Columnar>::Stack,
}
impl<T: Columnar> BinaryPushable<T> {
pub fn new(header: MessageHeader, sender: Sender<(MessageHeader, Vec<u8>)>, receiver: Receiver<Vec<u8>>) -> BinaryPushable<T> {
BinaryPushable {
header: header,
|
sender: sender,
receiver: receiver,
phantom: PhantomData,
buffer: Vec::new(),
stack: Default::default(),
|
random_line_split
|
|
load_balancer.rs
|
may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use std::convert::TryFrom;
use std::sync::atomic::{AtomicUsize, Ordering};
use rand::{thread_rng, Rng};
use serde::{Deserialize, Serialize};
use crate::{config::UpstreamEndpoints, filters::prelude::*, map_proto_enum};
crate::include_proto!("quilkin.extensions.filters.load_balancer.v1alpha1");
use self::quilkin::extensions::filters::load_balancer::v1alpha1::{
load_balancer::Policy as ProtoPolicy, LoadBalancer as ProtoConfig,
};
/// Policy represents how a [`LoadBalancerFilter`] distributes
/// packets across endpoints.
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
pub enum Policy {
/// Send packets to endpoints in turns.
#[serde(rename = "ROUND_ROBIN")]
RoundRobin,
/// Send packets to endpoints chosen at random.
#[serde(rename = "RANDOM")]
Random,
}
impl Default for Policy {
fn default() -> Self {
Policy::RoundRobin
}
}
/// Config represents configuration for a [`LoadBalancerFilter`].
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Config {
#[serde(default)]
policy: Policy,
}
impl TryFrom<ProtoConfig> for Config {
type Error = ConvertProtoConfigError;
fn try_from(p: ProtoConfig) -> Result<Self, Self::Error> {
let policy = p
.policy
.map(|policy| {
map_proto_enum!(
value = policy.value,
field = "policy",
proto_enum_type = ProtoPolicy,
target_enum_type = Policy,
variants = [RoundRobin, Random]
)
})
.transpose()?
.unwrap_or_else(Policy::default);
Ok(Self { policy })
}
}
/// EndpointChooser chooses from a set of endpoints that a proxy is connected to.
trait EndpointChooser: Send + Sync {
/// choose_endpoints asks for the next endpoint(s) to use.
fn choose_endpoints(&self, endpoints: &mut UpstreamEndpoints);
}
/// RoundRobinEndpointChooser chooses endpoints in round-robin order.
pub struct RoundRobinEndpointChooser {
next_endpoint: AtomicUsize,
}
impl RoundRobinEndpointChooser {
fn new() -> Self {
RoundRobinEndpointChooser {
next_endpoint: AtomicUsize::new(0),
}
}
}
impl EndpointChooser for RoundRobinEndpointChooser {
fn choose_endpoints(&self, endpoints: &mut UpstreamEndpoints) {
let count = self.next_endpoint.fetch_add(1, Ordering::Relaxed);
// Note: Unwrap is safe here because the index is guaranteed to be in range.
let num_endpoints = endpoints.size();
endpoints.keep(count % num_endpoints)
.expect("BUG: unwrap should have been safe because index into endpoints list should be in range");
}
}
/// RandomEndpointChooser chooses endpoints in random order.
pub struct RandomEndpointChooser;
impl EndpointChooser for RandomEndpointChooser {
fn choose_endpoints(&self, endpoints: &mut UpstreamEndpoints) {
// Note: Unwrap is safe here because the index is guaranteed to be in range.
let idx = (&mut thread_rng()).gen_range(0..endpoints.size());
endpoints.keep(idx)
.expect("BUG: unwrap should have been safe because index into endpoints list should be in range");
}
}
/// Creates instances of LoadBalancerFilter.
#[derive(Default)]
pub struct LoadBalancerFilterFactory;
/// LoadBalancerFilter load balances packets over the upstream endpoints.
#[crate::filter("quilkin.extensions.filters.load_balancer.v1alpha1.LoadBalancer")]
struct LoadBalancerFilter {
endpoint_chooser: Box<dyn EndpointChooser>,
}
impl FilterFactory for LoadBalancerFilterFactory {
fn name(&self) -> &'static str {
LoadBalancerFilter::FILTER_NAME
}
fn create_filter(&self, args: CreateFilterArgs) -> Result<Box<dyn Filter>, Error> {
let config: Config = self
.require_config(args.config)?
.deserialize::<Config, ProtoConfig>(self.name())?;
let endpoint_chooser: Box<dyn EndpointChooser> = match config.policy {
Policy::RoundRobin => Box::new(RoundRobinEndpointChooser::new()),
Policy::Random => Box::new(RandomEndpointChooser),
};
Ok(Box::new(LoadBalancerFilter { endpoint_chooser }))
}
}
impl Filter for LoadBalancerFilter {
fn read(&self, mut ctx: ReadContext) -> Option<ReadResponse> {
self.endpoint_chooser.choose_endpoints(&mut ctx.endpoints);
Some(ctx.into())
}
}
#[cfg(test)]
mod tests {
use std::collections::HashSet;
use std::convert::TryFrom;
use std::net::SocketAddr;
use super::quilkin::extensions::filters::load_balancer::v1alpha1::{
load_balancer::{Policy as ProtoPolicy, PolicyValue},
LoadBalancer as ProtoConfig,
};
use super::{Config, Policy};
use crate::cluster::Endpoint;
use crate::config::Endpoints;
use crate::filters::{
extensions::load_balancer::LoadBalancerFilterFactory, CreateFilterArgs, Filter,
FilterFactory, ReadContext,
};
use prometheus::Registry;
fn create_filter(config: &str) -> Box<dyn Filter> {
let factory = LoadBalancerFilterFactory;
factory
.create_filter(CreateFilterArgs::fixed(
Registry::default(),
Some(&serde_yaml::from_str(config).unwrap()),
))
.unwrap()
}
fn get_response_addresses(
filter: &dyn Filter,
input_addresses: &[SocketAddr],
) -> Vec<SocketAddr> {
filter
.read(ReadContext::new(
Endpoints::new(
input_addresses
.iter()
.map(|addr| Endpoint::from_address(*addr))
.collect(),
)
.unwrap()
.into(),
"127.0.0.1:8080".parse().unwrap(),
vec![],
))
.unwrap()
.endpoints
.iter()
.map(|ep| ep.address)
.collect::<Vec<_>>()
}
#[test]
fn convert_proto_config() {
let test_cases = vec![
(
"RandomPolicy",
ProtoConfig {
policy: Some(PolicyValue {
value: ProtoPolicy::Random as i32,
}),
},
Some(Config {
policy: Policy::Random,
}),
),
(
"RoundRobinPolicy",
ProtoConfig {
policy: Some(PolicyValue {
value: ProtoPolicy::RoundRobin as i32,
}),
},
Some(Config {
policy: Policy::RoundRobin,
}),
),
(
"should fail when invalid policy is provided",
ProtoConfig {
policy: Some(PolicyValue { value: 42 }),
},
None,
),
(
"should use correct default values",
ProtoConfig { policy: None },
Some(Config {
policy: Policy::default(),
}),
),
];
for (name, proto_config, expected) in test_cases {
let result = Config::try_from(proto_config);
assert_eq!(
result.is_err(),
expected.is_none(),
"{}: error expectation does not match",
name
);
if let Some(expected) = expected
|
}
}
#[test]
fn round_robin_load_balancer_policy() {
let addresses = vec![
"127.0.0.1:8080".parse().unwrap(),
"127.0.0.2:8080".parse().unwrap(),
"127.0.0.3:8080".parse().unwrap(),
];
let yaml = "
policy: ROUND_ROBIN
";
let filter = create_filter(yaml);
// Check that we repeat the same addresses in sequence forever.
let expected_sequence = addresses.iter().map(|addr| vec![*addr]).collect::<Vec<_>>();
for _ in 0..10 {
assert_eq!(
expected_sequence,
(0..addresses.len())
.map(|_| get_response_addresses(filter.as_ref(), &addresses))
.collect::<Vec<_>>()
);
}
}
#[test]
fn random_load_balancer_policy() {
let addresses = vec![
"127.0.0.1:8080".parse().unwrap(),
"127.0.0.2:8080".parse().unwrap(),
"127.0.0.3:8080".parse().unwrap(),
];
let yaml = "
policy: RANDOM
";
let filter = create_filter(yaml);
// Run a few selection rounds through the addresses.
let mut result_sequences = vec![];
for _ in 0..10 {
let sequence = (0..addresses.len())
.map(|_| get_response_addresses(filter.as_ref(), &addresses))
.collect::<Vec<_>>();
result_sequences.push(sequence);
}
// Check that every address was chosen at least once.
assert_eq
|
{
assert_eq!(expected, result.unwrap(), "{}", name);
}
|
conditional_block
|
load_balancer.rs
|
may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use std::convert::TryFrom;
use std::sync::atomic::{AtomicUsize, Ordering};
use rand::{thread_rng, Rng};
use serde::{Deserialize, Serialize};
use crate::{config::UpstreamEndpoints, filters::prelude::*, map_proto_enum};
crate::include_proto!("quilkin.extensions.filters.load_balancer.v1alpha1");
use self::quilkin::extensions::filters::load_balancer::v1alpha1::{
load_balancer::Policy as ProtoPolicy, LoadBalancer as ProtoConfig,
};
/// Policy represents how a [`LoadBalancerFilter`] distributes
/// packets across endpoints.
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
pub enum Policy {
/// Send packets to endpoints in turns.
#[serde(rename = "ROUND_ROBIN")]
RoundRobin,
/// Send packets to endpoints chosen at random.
#[serde(rename = "RANDOM")]
Random,
}
impl Default for Policy {
fn default() -> Self {
Policy::RoundRobin
}
}
/// Config represents configuration for a [`LoadBalancerFilter`].
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct
|
{
#[serde(default)]
policy: Policy,
}
impl TryFrom<ProtoConfig> for Config {
type Error = ConvertProtoConfigError;
fn try_from(p: ProtoConfig) -> Result<Self, Self::Error> {
let policy = p
.policy
.map(|policy| {
map_proto_enum!(
value = policy.value,
field = "policy",
proto_enum_type = ProtoPolicy,
target_enum_type = Policy,
variants = [RoundRobin, Random]
)
})
.transpose()?
.unwrap_or_else(Policy::default);
Ok(Self { policy })
}
}
/// EndpointChooser chooses from a set of endpoints that a proxy is connected to.
trait EndpointChooser: Send + Sync {
/// choose_endpoints asks for the next endpoint(s) to use.
fn choose_endpoints(&self, endpoints: &mut UpstreamEndpoints);
}
/// RoundRobinEndpointChooser chooses endpoints in round-robin order.
pub struct RoundRobinEndpointChooser {
next_endpoint: AtomicUsize,
}
impl RoundRobinEndpointChooser {
fn new() -> Self {
RoundRobinEndpointChooser {
next_endpoint: AtomicUsize::new(0),
}
}
}
impl EndpointChooser for RoundRobinEndpointChooser {
fn choose_endpoints(&self, endpoints: &mut UpstreamEndpoints) {
let count = self.next_endpoint.fetch_add(1, Ordering::Relaxed);
// Note: Unwrap is safe here because the index is guaranteed to be in range.
let num_endpoints = endpoints.size();
endpoints.keep(count % num_endpoints)
.expect("BUG: unwrap should have been safe because index into endpoints list should be in range");
}
}
/// RandomEndpointChooser chooses endpoints in random order.
pub struct RandomEndpointChooser;
impl EndpointChooser for RandomEndpointChooser {
fn choose_endpoints(&self, endpoints: &mut UpstreamEndpoints) {
// Note: Unwrap is safe here because the index is guaranteed to be in range.
let idx = (&mut thread_rng()).gen_range(0..endpoints.size());
endpoints.keep(idx)
.expect("BUG: unwrap should have been safe because index into endpoints list should be in range");
}
}
/// Creates instances of LoadBalancerFilter.
#[derive(Default)]
pub struct LoadBalancerFilterFactory;
/// LoadBalancerFilter load balances packets over the upstream endpoints.
#[crate::filter("quilkin.extensions.filters.load_balancer.v1alpha1.LoadBalancer")]
struct LoadBalancerFilter {
endpoint_chooser: Box<dyn EndpointChooser>,
}
impl FilterFactory for LoadBalancerFilterFactory {
fn name(&self) -> &'static str {
LoadBalancerFilter::FILTER_NAME
}
fn create_filter(&self, args: CreateFilterArgs) -> Result<Box<dyn Filter>, Error> {
let config: Config = self
.require_config(args.config)?
.deserialize::<Config, ProtoConfig>(self.name())?;
let endpoint_chooser: Box<dyn EndpointChooser> = match config.policy {
Policy::RoundRobin => Box::new(RoundRobinEndpointChooser::new()),
Policy::Random => Box::new(RandomEndpointChooser),
};
Ok(Box::new(LoadBalancerFilter { endpoint_chooser }))
}
}
impl Filter for LoadBalancerFilter {
fn read(&self, mut ctx: ReadContext) -> Option<ReadResponse> {
self.endpoint_chooser.choose_endpoints(&mut ctx.endpoints);
Some(ctx.into())
}
}
#[cfg(test)]
mod tests {
use std::collections::HashSet;
use std::convert::TryFrom;
use std::net::SocketAddr;
use super::quilkin::extensions::filters::load_balancer::v1alpha1::{
load_balancer::{Policy as ProtoPolicy, PolicyValue},
LoadBalancer as ProtoConfig,
};
use super::{Config, Policy};
use crate::cluster::Endpoint;
use crate::config::Endpoints;
use crate::filters::{
extensions::load_balancer::LoadBalancerFilterFactory, CreateFilterArgs, Filter,
FilterFactory, ReadContext,
};
use prometheus::Registry;
fn create_filter(config: &str) -> Box<dyn Filter> {
let factory = LoadBalancerFilterFactory;
factory
.create_filter(CreateFilterArgs::fixed(
Registry::default(),
Some(&serde_yaml::from_str(config).unwrap()),
))
.unwrap()
}
fn get_response_addresses(
filter: &dyn Filter,
input_addresses: &[SocketAddr],
) -> Vec<SocketAddr> {
filter
.read(ReadContext::new(
Endpoints::new(
input_addresses
.iter()
.map(|addr| Endpoint::from_address(*addr))
.collect(),
)
.unwrap()
.into(),
"127.0.0.1:8080".parse().unwrap(),
vec![],
))
.unwrap()
.endpoints
.iter()
.map(|ep| ep.address)
.collect::<Vec<_>>()
}
#[test]
fn convert_proto_config() {
let test_cases = vec![
(
"RandomPolicy",
ProtoConfig {
policy: Some(PolicyValue {
value: ProtoPolicy::Random as i32,
}),
},
Some(Config {
policy: Policy::Random,
}),
),
(
"RoundRobinPolicy",
ProtoConfig {
policy: Some(PolicyValue {
value: ProtoPolicy::RoundRobin as i32,
}),
},
Some(Config {
policy: Policy::RoundRobin,
}),
),
(
"should fail when invalid policy is provided",
ProtoConfig {
policy: Some(PolicyValue { value: 42 }),
},
None,
),
(
"should use correct default values",
ProtoConfig { policy: None },
Some(Config {
policy: Policy::default(),
}),
),
];
for (name, proto_config, expected) in test_cases {
let result = Config::try_from(proto_config);
assert_eq!(
result.is_err(),
expected.is_none(),
"{}: error expectation does not match",
name
);
if let Some(expected) = expected {
assert_eq!(expected, result.unwrap(), "{}", name);
}
}
}
#[test]
fn round_robin_load_balancer_policy() {
let addresses = vec![
"127.0.0.1:8080".parse().unwrap(),
"127.0.0.2:8080".parse().unwrap(),
"127.0.0.3:8080".parse().unwrap(),
];
let yaml = "
policy: ROUND_ROBIN
";
let filter = create_filter(yaml);
// Check that we repeat the same addresses in sequence forever.
let expected_sequence = addresses.iter().map(|addr| vec![*addr]).collect::<Vec<_>>();
for _ in 0..10 {
assert_eq!(
expected_sequence,
(0..addresses.len())
.map(|_| get_response_addresses(filter.as_ref(), &addresses))
.collect::<Vec<_>>()
);
}
}
#[test]
fn random_load_balancer_policy() {
let addresses = vec![
"127.0.0.1:8080".parse().unwrap(),
"127.0.0.2:8080".parse().unwrap(),
"127.0.0.3:8080".parse().unwrap(),
];
let yaml = "
policy: RANDOM
";
let filter = create_filter(yaml);
// Run a few selection rounds through the addresses.
let mut result_sequences = vec![];
for _ in 0..10 {
let sequence = (0..addresses.len())
.map(|_| get_response_addresses(filter.as_ref(), &addresses))
.collect::<Vec<_>>();
result_sequences.push(sequence);
}
// Check that every address was chosen at least once.
assert_eq!(
|
Config
|
identifier_name
|
load_balancer.rs
|
You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use std::convert::TryFrom;
use std::sync::atomic::{AtomicUsize, Ordering};
use rand::{thread_rng, Rng};
use serde::{Deserialize, Serialize};
use crate::{config::UpstreamEndpoints, filters::prelude::*, map_proto_enum};
crate::include_proto!("quilkin.extensions.filters.load_balancer.v1alpha1");
use self::quilkin::extensions::filters::load_balancer::v1alpha1::{
load_balancer::Policy as ProtoPolicy, LoadBalancer as ProtoConfig,
};
/// Policy represents how a [`LoadBalancerFilter`] distributes
/// packets across endpoints.
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
pub enum Policy {
/// Send packets to endpoints in turns.
#[serde(rename = "ROUND_ROBIN")]
RoundRobin,
/// Send packets to endpoints chosen at random.
#[serde(rename = "RANDOM")]
Random,
}
impl Default for Policy {
fn default() -> Self {
Policy::RoundRobin
}
}
/// Config represents configuration for a [`LoadBalancerFilter`].
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Config {
#[serde(default)]
policy: Policy,
}
impl TryFrom<ProtoConfig> for Config {
type Error = ConvertProtoConfigError;
fn try_from(p: ProtoConfig) -> Result<Self, Self::Error> {
let policy = p
.policy
.map(|policy| {
map_proto_enum!(
value = policy.value,
field = "policy",
proto_enum_type = ProtoPolicy,
target_enum_type = Policy,
variants = [RoundRobin, Random]
)
})
.transpose()?
.unwrap_or_else(Policy::default);
Ok(Self { policy })
}
}
/// EndpointChooser chooses from a set of endpoints that a proxy is connected to.
trait EndpointChooser: Send + Sync {
/// choose_endpoints asks for the next endpoint(s) to use.
fn choose_endpoints(&self, endpoints: &mut UpstreamEndpoints);
}
/// RoundRobinEndpointChooser chooses endpoints in round-robin order.
pub struct RoundRobinEndpointChooser {
next_endpoint: AtomicUsize,
}
impl RoundRobinEndpointChooser {
fn new() -> Self {
RoundRobinEndpointChooser {
next_endpoint: AtomicUsize::new(0),
}
}
}
impl EndpointChooser for RoundRobinEndpointChooser {
fn choose_endpoints(&self, endpoints: &mut UpstreamEndpoints) {
let count = self.next_endpoint.fetch_add(1, Ordering::Relaxed);
// Note: Unwrap is safe here because the index is guaranteed to be in range.
let num_endpoints = endpoints.size();
endpoints.keep(count % num_endpoints)
.expect("BUG: unwrap should have been safe because index into endpoints list should be in range");
}
}
/// RandomEndpointChooser chooses endpoints in random order.
pub struct RandomEndpointChooser;
impl EndpointChooser for RandomEndpointChooser {
fn choose_endpoints(&self, endpoints: &mut UpstreamEndpoints) {
// Note: Unwrap is safe here because the index is guaranteed to be in range.
let idx = (&mut thread_rng()).gen_range(0..endpoints.size());
endpoints.keep(idx)
.expect("BUG: unwrap should have been safe because index into endpoints list should be in range");
}
}
/// Creates instances of LoadBalancerFilter.
#[derive(Default)]
pub struct LoadBalancerFilterFactory;
/// LoadBalancerFilter load balances packets over the upstream endpoints.
#[crate::filter("quilkin.extensions.filters.load_balancer.v1alpha1.LoadBalancer")]
struct LoadBalancerFilter {
endpoint_chooser: Box<dyn EndpointChooser>,
}
impl FilterFactory for LoadBalancerFilterFactory {
fn name(&self) -> &'static str {
LoadBalancerFilter::FILTER_NAME
}
fn create_filter(&self, args: CreateFilterArgs) -> Result<Box<dyn Filter>, Error> {
let config: Config = self
.require_config(args.config)?
.deserialize::<Config, ProtoConfig>(self.name())?;
let endpoint_chooser: Box<dyn EndpointChooser> = match config.policy {
Policy::RoundRobin => Box::new(RoundRobinEndpointChooser::new()),
Policy::Random => Box::new(RandomEndpointChooser),
};
Ok(Box::new(LoadBalancerFilter { endpoint_chooser }))
}
}
impl Filter for LoadBalancerFilter {
fn read(&self, mut ctx: ReadContext) -> Option<ReadResponse> {
self.endpoint_chooser.choose_endpoints(&mut ctx.endpoints);
Some(ctx.into())
}
}
#[cfg(test)]
mod tests {
use std::collections::HashSet;
use std::convert::TryFrom;
use std::net::SocketAddr;
use super::quilkin::extensions::filters::load_balancer::v1alpha1::{
load_balancer::{Policy as ProtoPolicy, PolicyValue},
LoadBalancer as ProtoConfig,
};
use super::{Config, Policy};
use crate::cluster::Endpoint;
use crate::config::Endpoints;
use crate::filters::{
extensions::load_balancer::LoadBalancerFilterFactory, CreateFilterArgs, Filter,
FilterFactory, ReadContext,
};
use prometheus::Registry;
fn create_filter(config: &str) -> Box<dyn Filter> {
let factory = LoadBalancerFilterFactory;
factory
.create_filter(CreateFilterArgs::fixed(
Registry::default(),
Some(&serde_yaml::from_str(config).unwrap()),
))
.unwrap()
}
fn get_response_addresses(
filter: &dyn Filter,
input_addresses: &[SocketAddr],
) -> Vec<SocketAddr> {
filter
.read(ReadContext::new(
Endpoints::new(
input_addresses
.iter()
.map(|addr| Endpoint::from_address(*addr))
.collect(),
)
.unwrap()
.into(),
"127.0.0.1:8080".parse().unwrap(),
vec![],
))
.unwrap()
.endpoints
.iter()
.map(|ep| ep.address)
.collect::<Vec<_>>()
}
#[test]
|
policy: Some(PolicyValue {
value: ProtoPolicy::Random as i32,
}),
},
Some(Config {
policy: Policy::Random,
}),
),
(
"RoundRobinPolicy",
ProtoConfig {
policy: Some(PolicyValue {
value: ProtoPolicy::RoundRobin as i32,
}),
},
Some(Config {
policy: Policy::RoundRobin,
}),
),
(
"should fail when invalid policy is provided",
ProtoConfig {
policy: Some(PolicyValue { value: 42 }),
},
None,
),
(
"should use correct default values",
ProtoConfig { policy: None },
Some(Config {
policy: Policy::default(),
}),
),
];
for (name, proto_config, expected) in test_cases {
let result = Config::try_from(proto_config);
assert_eq!(
result.is_err(),
expected.is_none(),
"{}: error expectation does not match",
name
);
if let Some(expected) = expected {
assert_eq!(expected, result.unwrap(), "{}", name);
}
}
}
#[test]
fn round_robin_load_balancer_policy() {
let addresses = vec![
"127.0.0.1:8080".parse().unwrap(),
"127.0.0.2:8080".parse().unwrap(),
"127.0.0.3:8080".parse().unwrap(),
];
let yaml = "
policy: ROUND_ROBIN
";
let filter = create_filter(yaml);
// Check that we repeat the same addresses in sequence forever.
let expected_sequence = addresses.iter().map(|addr| vec![*addr]).collect::<Vec<_>>();
for _ in 0..10 {
assert_eq!(
expected_sequence,
(0..addresses.len())
.map(|_| get_response_addresses(filter.as_ref(), &addresses))
.collect::<Vec<_>>()
);
}
}
#[test]
fn random_load_balancer_policy() {
let addresses = vec![
"127.0.0.1:8080".parse().unwrap(),
"127.0.0.2:8080".parse().unwrap(),
"127.0.0.3:8080".parse().unwrap(),
];
let yaml = "
policy: RANDOM
";
let filter = create_filter(yaml);
// Run a few selection rounds through the addresses.
let mut result_sequences = vec![];
for _ in 0..10 {
let sequence = (0..addresses.len())
.map(|_| get_response_addresses(filter.as_ref(), &addresses))
.collect::<Vec<_>>();
result_sequences.push(sequence);
}
// Check that every address was chosen at least once.
assert_eq!(
|
fn convert_proto_config() {
let test_cases = vec![
(
"RandomPolicy",
ProtoConfig {
|
random_line_split
|
usher.go
|
qualified domain whose mappings we want
DBPath string // full path to database for Domain
ConfigPath string // full path to usher config file
}
type Entry struct {
Code string
Url string
}
type ConfigEntry struct {
Type string `yaml:"type"`
AWSKey string `yaml:"aws_key,omitempty"`
AWSSecret string `yaml:"aws_secret,omitempty"`
AWSRegion string `yaml:"aws_region,omitempty"`
}
// NewDB creates a DB struct with members derived from parameters,
// the environment, or defaults (in that order). It does no checking
// that the values produced are sane or exist on the filesystem.
func NewDB(domain string) (*DB, error) {
// Get root
root := os.Getenv("USHER_ROOT")
if root == "" {
// If USHER_ROOT is unset, check if there is an usher.yml in the cwd
stat, err := os.Stat("usher.yml")
if err == nil && !stat.IsDir()
|
}
if root == "" {
// If root is still unset, default to "os.UserConfigDir()/usher"
configDir, err := os.UserConfigDir()
if err != nil {
return nil, err
}
root = filepath.Join(configDir, "usher")
}
// Derive domain if not set - check for USHER_DOMAIN in environment
if domain == "" {
domain = os.Getenv("USHER_DOMAIN")
}
// Else infer the domain if only one database exists
if domain == "" {
matches, _ := filepath.Glob(filepath.Join(root, "*.*.yml"))
if len(matches) == 1 {
// Exactly one match - strip .yml suffix to get domain
re := regexp.MustCompile(`.yml$`)
domain = re.ReplaceAllLiteralString(filepath.Base(matches[0]), "")
}
}
// Else give up with an error
if domain == "" {
return nil, errors.New("Domain not passed as parameter or set in env USHER_DOMAIN")
}
// Set DBPath
dbpath := filepath.Join(root, domain+".yml")
// Set ConfigPath
configpath := filepath.Join(root, configfile)
return &DB{Root: root, Domain: domain, DBPath: dbpath, ConfigPath: configpath}, nil
}
// Init checks and creates the following, if they don't exist:
// - an usher root directory
// - an usher database for the db.Domain
// - an entry in the user config file for db.Domain
func (db *DB) Init() (dbCreated bool, err error) {
dbCreated = false
// Ensure root exists
err = os.MkdirAll(db.Root, 0755)
if err != nil {
return dbCreated, err
}
// Ensure database exists
_, err = os.Stat(db.DBPath)
if err == nil {
return dbCreated, nil // exists
}
if err != nil && !os.IsNotExist(err) {
return dbCreated, err // unexpected error
}
// Database does not exist - create
fh, err := os.Create(db.DBPath)
fh.Close()
if err != nil {
return dbCreated, err
}
dbCreated = true
// Ensure configfile exists
_, err = os.Stat(db.ConfigPath)
if err == nil {
_, err := db.readConfig()
if err != nil {
if err != ErrNotFound {
return dbCreated, err
}
}
err = db.appendConfigString(db.configPlaceholder())
if err != nil {
return dbCreated, err
}
} else {
// Create a placeholder config file for domain
err = db.writeConfigString(db.configPlaceholder())
if err != nil {
return dbCreated, err
}
}
return dbCreated, nil
}
// List returns the set of database entries whose code matches glob
func (db *DB) List(glob string) ([]Entry, error) {
// FIXME: first-pass - ignore glob
mappings, err := db.readDB()
if err != nil {
return nil, err
}
// Extract codes and sort
codes := make([]string, len(mappings))
i := 0
for code := range mappings {
codes[i] = code
i++
}
sort.Strings(codes)
// Compile entries
var entries = make([]Entry, len(mappings))
i = 0
for _, code := range codes {
entries[i] = Entry{Code: code, Url: mappings[code]}
i++
}
return entries, nil
}
// Add a mapping for url and code to the database.
// If code is missing, a random code will be generated and returned.
func (db *DB) Add(url, code string) (string, error) {
mappings, err := db.readDB()
if err != nil {
return "", err
}
if code == "" {
code = randomCode(mappings)
} else {
// Check for parameter inversion
reUrl := regexp.MustCompile(`^https?://`)
if !reUrl.MatchString(url) && reUrl.MatchString(code) {
url, code = code, url
}
// Check whether code is already used
dburl, exists := mappings[code]
if exists {
if dburl == url {
// Trying to re-add the same url is not an error, just a noop
return code, nil
}
return code, ErrCodeExists
}
}
mappings[code] = url
err = db.writeDB(mappings)
if err != nil {
return code, err
}
return code, nil
}
// Update an existing mapping in the database, changing the URL.
func (db *DB) Update(url, code string) error {
mappings, err := db.readDB()
if err != nil {
return err
}
// Check for parameter inversion
reUrl := regexp.MustCompile(`^https?://`)
if !reUrl.MatchString(url) && reUrl.MatchString(code) {
url, code = code, url
}
// If code is missing, abort
dburl, exists := mappings[code]
if !exists {
return ErrNotFound
}
// Trying to update to the same url is not an error, just a noop
if dburl == url {
return nil
}
mappings[code] = url
err = db.writeDB(mappings)
if err != nil {
return err
}
return nil
}
// Remove the mapping with code from the database
// Returns ErrNotFound if code does not exist in the database
func (db *DB) Remove(code string) error {
mappings, err := db.readDB()
if err != nil {
return err
}
_, exists := mappings[code]
if !exists {
return ErrNotFound
}
delete(mappings, code)
err = db.writeDB(mappings)
if err != nil {
return err
}
return nil
}
// Push syncs all current mappings with the backend configured for db.Domain
// in db.ConfigPath
func (db *DB) Push() error {
config, err := db.readConfig()
if err != nil {
return err
}
if config.Type == "" {
return fmt.Errorf("no 'type' field found for %q in config %q\n",
db.Domain, db.ConfigPath)
}
switch config.Type {
case "s3":
err = db.pushS3(config)
if err != nil {
return err
}
case "render":
err = db.pushRender()
if err != nil {
return err
}
case "unconfigured":
return ErrPushTypeUnconfigured
default:
return fmt.Errorf("invalid config backend type %q found for %q: %w",
config.Type, db.Domain, ErrPushTypeBad)
}
return nil
}
// readDB is a utility function to read all mappings from db.DBPath
// and return as a go map
func (db *DB) readDB() (map[string]string, error) {
data, err := ioutil.ReadFile(db.DBPath)
if err != nil {
return nil, err
}
var mappings map[string]string
err = yaml.Unmarshal(data, &mappings)
if err != nil {
return nil, err
}
if len(mappings) == 0 {
mappings = make(map[string]string)
}
return mappings, nil
}
// writeDB is a utility function to write mappings (as yaml) to db.DBPath
func (db *DB) writeDB(mappings map[string]string) error {
var data []byte
var err error
if len(mappings) > 0 {
data, err = yaml.Marshal(mappings)
if err != nil {
return err
}
}
tmpfile := db.DBPath + ".tmp"
err = ioutil.WriteFile(tmpfile, data, 0644)
if err != nil {
return err
}
err = os.Rename(tmpfile, db.DBPath)
if err != nil {
return err
}
return nil
}
// readConfig is a utility function to read the config entry for
// db.Domain from db.ConfigPath file
func (db *DB) readConfig() (*ConfigEntry, error) {
data, err := ioutil.ReadFile(db
|
{
cwd, err := os.Getwd()
if err == nil {
root = cwd
}
}
|
conditional_block
|
usher.go
|
Dir, "usher")
}
// Derive domain if not set - check for USHER_DOMAIN in environment
if domain == "" {
domain = os.Getenv("USHER_DOMAIN")
}
// Else infer the domain if only one database exists
if domain == "" {
matches, _ := filepath.Glob(filepath.Join(root, "*.*.yml"))
if len(matches) == 1 {
// Exactly one match - strip .yml suffix to get domain
re := regexp.MustCompile(`.yml$`)
domain = re.ReplaceAllLiteralString(filepath.Base(matches[0]), "")
}
}
// Else give up with an error
if domain == "" {
return nil, errors.New("Domain not passed as parameter or set in env USHER_DOMAIN")
}
// Set DBPath
dbpath := filepath.Join(root, domain+".yml")
// Set ConfigPath
configpath := filepath.Join(root, configfile)
return &DB{Root: root, Domain: domain, DBPath: dbpath, ConfigPath: configpath}, nil
}
// Init checks and creates the following, if they don't exist:
// - an usher root directory
// - an usher database for the db.Domain
// - an entry in the user config file for db.Domain
func (db *DB) Init() (dbCreated bool, err error) {
dbCreated = false
// Ensure root exists
err = os.MkdirAll(db.Root, 0755)
if err != nil {
return dbCreated, err
}
// Ensure database exists
_, err = os.Stat(db.DBPath)
if err == nil {
return dbCreated, nil // exists
}
if err != nil && !os.IsNotExist(err) {
return dbCreated, err // unexpected error
}
// Database does not exist - create
fh, err := os.Create(db.DBPath)
fh.Close()
if err != nil {
return dbCreated, err
}
dbCreated = true
// Ensure configfile exists
_, err = os.Stat(db.ConfigPath)
if err == nil {
_, err := db.readConfig()
if err != nil {
if err != ErrNotFound {
return dbCreated, err
}
}
err = db.appendConfigString(db.configPlaceholder())
if err != nil {
return dbCreated, err
}
} else {
// Create a placeholder config file for domain
err = db.writeConfigString(db.configPlaceholder())
if err != nil {
return dbCreated, err
}
}
return dbCreated, nil
}
// List returns the set of database entries whose code matches glob
func (db *DB) List(glob string) ([]Entry, error) {
// FIXME: first-pass - ignore glob
mappings, err := db.readDB()
if err != nil {
return nil, err
}
// Extract codes and sort
codes := make([]string, len(mappings))
i := 0
for code := range mappings {
codes[i] = code
i++
}
sort.Strings(codes)
// Compile entries
var entries = make([]Entry, len(mappings))
i = 0
for _, code := range codes {
entries[i] = Entry{Code: code, Url: mappings[code]}
i++
}
return entries, nil
}
// Add a mapping for url and code to the database.
// If code is missing, a random code will be generated and returned.
func (db *DB) Add(url, code string) (string, error) {
mappings, err := db.readDB()
if err != nil {
return "", err
}
if code == "" {
code = randomCode(mappings)
} else {
// Check for parameter inversion
reUrl := regexp.MustCompile(`^https?://`)
if !reUrl.MatchString(url) && reUrl.MatchString(code) {
url, code = code, url
}
// Check whether code is already used
dburl, exists := mappings[code]
if exists {
if dburl == url {
// Trying to re-add the same url is not an error, just a noop
return code, nil
}
return code, ErrCodeExists
}
}
mappings[code] = url
err = db.writeDB(mappings)
if err != nil {
return code, err
}
return code, nil
}
// Update an existing mapping in the database, changing the URL.
func (db *DB) Update(url, code string) error {
mappings, err := db.readDB()
if err != nil {
return err
}
// Check for parameter inversion
reUrl := regexp.MustCompile(`^https?://`)
if !reUrl.MatchString(url) && reUrl.MatchString(code) {
url, code = code, url
}
// If code is missing, abort
dburl, exists := mappings[code]
if !exists {
return ErrNotFound
}
// Trying to update to the same url is not an error, just a noop
if dburl == url {
return nil
}
mappings[code] = url
err = db.writeDB(mappings)
if err != nil {
return err
}
return nil
}
// Remove the mapping with code from the database
// Returns ErrNotFound if code does not exist in the database
func (db *DB) Remove(code string) error {
mappings, err := db.readDB()
if err != nil {
return err
}
_, exists := mappings[code]
if !exists {
return ErrNotFound
}
delete(mappings, code)
err = db.writeDB(mappings)
if err != nil {
return err
}
return nil
}
// Push syncs all current mappings with the backend configured for db.Domain
// in db.ConfigPath
func (db *DB) Push() error {
config, err := db.readConfig()
if err != nil {
return err
}
if config.Type == "" {
return fmt.Errorf("no 'type' field found for %q in config %q\n",
db.Domain, db.ConfigPath)
}
switch config.Type {
case "s3":
err = db.pushS3(config)
if err != nil {
return err
}
case "render":
err = db.pushRender()
if err != nil {
return err
}
case "unconfigured":
return ErrPushTypeUnconfigured
default:
return fmt.Errorf("invalid config backend type %q found for %q: %w",
config.Type, db.Domain, ErrPushTypeBad)
}
return nil
}
// readDB is a utility function to read all mappings from db.DBPath
// and return as a go map
func (db *DB) readDB() (map[string]string, error) {
data, err := ioutil.ReadFile(db.DBPath)
if err != nil {
return nil, err
}
var mappings map[string]string
err = yaml.Unmarshal(data, &mappings)
if err != nil {
return nil, err
}
if len(mappings) == 0 {
mappings = make(map[string]string)
}
return mappings, nil
}
// writeDB is a utility function to write mappings (as yaml) to db.DBPath
func (db *DB) writeDB(mappings map[string]string) error {
var data []byte
var err error
if len(mappings) > 0 {
data, err = yaml.Marshal(mappings)
if err != nil {
return err
}
}
tmpfile := db.DBPath + ".tmp"
err = ioutil.WriteFile(tmpfile, data, 0644)
if err != nil {
return err
}
err = os.Rename(tmpfile, db.DBPath)
if err != nil {
return err
}
return nil
}
// readConfig is a utility function to read the config entry for
// db.Domain from db.ConfigPath file
func (db *DB) readConfig() (*ConfigEntry, error) {
data, err := ioutil.ReadFile(db.ConfigPath)
if err != nil {
return nil, err
}
var entries map[string]ConfigEntry
err = yaml.Unmarshal(data, &entries)
if err != nil {
return nil, err
}
entry, exists := entries[db.Domain]
if !exists {
return nil, ErrNotFound
}
return &entry, nil
}
// writeConfigString is a utility function to write data to db.ConfigPath
func (db *DB) writeConfigString(data string) error {
tmpfile := db.ConfigPath + ".tmp"
err := ioutil.WriteFile(tmpfile, []byte(data), 0600)
if err != nil {
return err
}
err = os.Rename(tmpfile, db.ConfigPath)
if err != nil {
return err
}
return nil
}
// appendConfigString is a utility function to write data to db.ConfigPath
func (db *DB) appendConfigString(data string) error
|
{
config, err := ioutil.ReadFile(db.ConfigPath)
if err != nil {
return err
}
config = append(config, []byte(data)...)
tmpfile := db.ConfigPath + ".tmp"
err = ioutil.WriteFile(tmpfile, config, 0600)
if err != nil {
return err
}
err = os.Rename(tmpfile, db.ConfigPath)
if err != nil {
return err
}
return nil
}
|
identifier_body
|
|
usher.go
|
-qualified domain whose mappings we want
DBPath string // full path to database for Domain
ConfigPath string // full path to usher config file
}
type Entry struct {
Code string
Url string
}
type ConfigEntry struct {
Type string `yaml:"type"`
AWSKey string `yaml:"aws_key,omitempty"`
AWSSecret string `yaml:"aws_secret,omitempty"`
AWSRegion string `yaml:"aws_region,omitempty"`
}
// NewDB creates a DB struct with members derived from parameters,
// the environment, or defaults (in that order). It does no checking
// that the values produced are sane or exist on the filesystem.
func NewDB(domain string) (*DB, error) {
// Get root
root := os.Getenv("USHER_ROOT")
if root == "" {
// If USHER_ROOT is unset, check if there is an usher.yml in the cwd
stat, err := os.Stat("usher.yml")
if err == nil && !stat.IsDir() {
cwd, err := os.Getwd()
if err == nil {
root = cwd
}
}
}
if root == "" {
// If root is still unset, default to "os.UserConfigDir()/usher"
configDir, err := os.UserConfigDir()
if err != nil {
return nil, err
}
root = filepath.Join(configDir, "usher")
}
// Derive domain if not set - check for USHER_DOMAIN in environment
if domain == "" {
domain = os.Getenv("USHER_DOMAIN")
}
// Else infer the domain if only one database exists
if domain == "" {
matches, _ := filepath.Glob(filepath.Join(root, "*.*.yml"))
if len(matches) == 1 {
// Exactly one match - strip .yml suffix to get domain
re := regexp.MustCompile(`.yml$`)
domain = re.ReplaceAllLiteralString(filepath.Base(matches[0]), "")
}
}
// Else give up with an error
if domain == "" {
return nil, errors.New("Domain not passed as parameter or set in env USHER_DOMAIN")
}
// Set DBPath
dbpath := filepath.Join(root, domain+".yml")
// Set ConfigPath
configpath := filepath.Join(root, configfile)
return &DB{Root: root, Domain: domain, DBPath: dbpath, ConfigPath: configpath}, nil
}
// Init checks and creates the following, if they don't exist:
// - an usher root directory
// - an usher database for the db.Domain
// - an entry in the user config file for db.Domain
func (db *DB) Init() (dbCreated bool, err error) {
dbCreated = false
// Ensure root exists
err = os.MkdirAll(db.Root, 0755)
if err != nil {
return dbCreated, err
}
// Ensure database exists
_, err = os.Stat(db.DBPath)
if err == nil {
return dbCreated, nil // exists
}
if err != nil && !os.IsNotExist(err) {
return dbCreated, err // unexpected error
}
// Database does not exist - create
fh, err := os.Create(db.DBPath)
fh.Close()
if err != nil {
return dbCreated, err
}
dbCreated = true
// Ensure configfile exists
_, err = os.Stat(db.ConfigPath)
if err == nil {
_, err := db.readConfig()
if err != nil {
if err != ErrNotFound {
return dbCreated, err
}
}
err = db.appendConfigString(db.configPlaceholder())
if err != nil {
return dbCreated, err
}
} else {
// Create a placeholder config file for domain
err = db.writeConfigString(db.configPlaceholder())
if err != nil {
return dbCreated, err
}
}
return dbCreated, nil
}
// List returns the set of database entries whose code matches glob
func (db *DB) List(glob string) ([]Entry, error) {
// FIXME: first-pass - ignore glob
mappings, err := db.readDB()
if err != nil {
return nil, err
}
// Extract codes and sort
codes := make([]string, len(mappings))
i := 0
for code := range mappings {
|
// Compile entries
var entries = make([]Entry, len(mappings))
i = 0
for _, code := range codes {
entries[i] = Entry{Code: code, Url: mappings[code]}
i++
}
return entries, nil
}
// Add a mapping for url and code to the database.
// If code is missing, a random code will be generated and returned.
func (db *DB) Add(url, code string) (string, error) {
mappings, err := db.readDB()
if err != nil {
return "", err
}
if code == "" {
code = randomCode(mappings)
} else {
// Check for parameter inversion
reUrl := regexp.MustCompile(`^https?://`)
if !reUrl.MatchString(url) && reUrl.MatchString(code) {
url, code = code, url
}
// Check whether code is already used
dburl, exists := mappings[code]
if exists {
if dburl == url {
// Trying to re-add the same url is not an error, just a noop
return code, nil
}
return code, ErrCodeExists
}
}
mappings[code] = url
err = db.writeDB(mappings)
if err != nil {
return code, err
}
return code, nil
}
// Update an existing mapping in the database, changing the URL.
func (db *DB) Update(url, code string) error {
mappings, err := db.readDB()
if err != nil {
return err
}
// Check for parameter inversion
reUrl := regexp.MustCompile(`^https?://`)
if !reUrl.MatchString(url) && reUrl.MatchString(code) {
url, code = code, url
}
// If code is missing, abort
dburl, exists := mappings[code]
if !exists {
return ErrNotFound
}
// Trying to update to the same url is not an error, just a noop
if dburl == url {
return nil
}
mappings[code] = url
err = db.writeDB(mappings)
if err != nil {
return err
}
return nil
}
// Remove the mapping with code from the database
// Returns ErrNotFound if code does not exist in the database
func (db *DB) Remove(code string) error {
mappings, err := db.readDB()
if err != nil {
return err
}
_, exists := mappings[code]
if !exists {
return ErrNotFound
}
delete(mappings, code)
err = db.writeDB(mappings)
if err != nil {
return err
}
return nil
}
// Push syncs all current mappings with the backend configured for db.Domain
// in db.ConfigPath
func (db *DB) Push() error {
config, err := db.readConfig()
if err != nil {
return err
}
if config.Type == "" {
return fmt.Errorf("no 'type' field found for %q in config %q\n",
db.Domain, db.ConfigPath)
}
switch config.Type {
case "s3":
err = db.pushS3(config)
if err != nil {
return err
}
case "render":
err = db.pushRender()
if err != nil {
return err
}
case "unconfigured":
return ErrPushTypeUnconfigured
default:
return fmt.Errorf("invalid config backend type %q found for %q: %w",
config.Type, db.Domain, ErrPushTypeBad)
}
return nil
}
// readDB is a utility function to read all mappings from db.DBPath
// and return as a go map
func (db *DB) readDB() (map[string]string, error) {
data, err := ioutil.ReadFile(db.DBPath)
if err != nil {
return nil, err
}
var mappings map[string]string
err = yaml.Unmarshal(data, &mappings)
if err != nil {
return nil, err
}
if len(mappings) == 0 {
mappings = make(map[string]string)
}
return mappings, nil
}
// writeDB is a utility function to write mappings (as yaml) to db.DBPath
func (db *DB) writeDB(mappings map[string]string) error {
var data []byte
var err error
if len(mappings) > 0 {
data, err = yaml.Marshal(mappings)
if err != nil {
return err
}
}
tmpfile := db.DBPath + ".tmp"
err = ioutil.WriteFile(tmpfile, data, 0644)
if err != nil {
return err
}
err = os.Rename(tmpfile, db.DBPath)
if err != nil {
return err
}
return nil
}
// readConfig is a utility function to read the config entry for
// db.Domain from db.ConfigPath file
func (db *DB) readConfig() (*ConfigEntry, error) {
data, err := ioutil.ReadFile(db.Config
|
codes[i] = code
i++
}
sort.Strings(codes)
|
random_line_split
|
usher.go
|
yml"))
if len(matches) == 1 {
// Exactly one match - strip .yml suffix to get domain
re := regexp.MustCompile(`.yml$`)
domain = re.ReplaceAllLiteralString(filepath.Base(matches[0]), "")
}
}
// Else give up with an error
if domain == "" {
return nil, errors.New("Domain not passed as parameter or set in env USHER_DOMAIN")
}
// Set DBPath
dbpath := filepath.Join(root, domain+".yml")
// Set ConfigPath
configpath := filepath.Join(root, configfile)
return &DB{Root: root, Domain: domain, DBPath: dbpath, ConfigPath: configpath}, nil
}
// Init checks and creates the following, if they don't exist:
// - an usher root directory
// - an usher database for the db.Domain
// - an entry in the user config file for db.Domain
func (db *DB) Init() (dbCreated bool, err error) {
dbCreated = false
// Ensure root exists
err = os.MkdirAll(db.Root, 0755)
if err != nil {
return dbCreated, err
}
// Ensure database exists
_, err = os.Stat(db.DBPath)
if err == nil {
return dbCreated, nil // exists
}
if err != nil && !os.IsNotExist(err) {
return dbCreated, err // unexpected error
}
// Database does not exist - create
fh, err := os.Create(db.DBPath)
fh.Close()
if err != nil {
return dbCreated, err
}
dbCreated = true
// Ensure configfile exists
_, err = os.Stat(db.ConfigPath)
if err == nil {
_, err := db.readConfig()
if err != nil {
if err != ErrNotFound {
return dbCreated, err
}
}
err = db.appendConfigString(db.configPlaceholder())
if err != nil {
return dbCreated, err
}
} else {
// Create a placeholder config file for domain
err = db.writeConfigString(db.configPlaceholder())
if err != nil {
return dbCreated, err
}
}
return dbCreated, nil
}
// List returns the set of database entries whose code matches glob
func (db *DB) List(glob string) ([]Entry, error) {
// FIXME: first-pass - ignore glob
mappings, err := db.readDB()
if err != nil {
return nil, err
}
// Extract codes and sort
codes := make([]string, len(mappings))
i := 0
for code := range mappings {
codes[i] = code
i++
}
sort.Strings(codes)
// Compile entries
var entries = make([]Entry, len(mappings))
i = 0
for _, code := range codes {
entries[i] = Entry{Code: code, Url: mappings[code]}
i++
}
return entries, nil
}
// Add a mapping for url and code to the database.
// If code is missing, a random code will be generated and returned.
func (db *DB) Add(url, code string) (string, error) {
mappings, err := db.readDB()
if err != nil {
return "", err
}
if code == "" {
code = randomCode(mappings)
} else {
// Check for parameter inversion
reUrl := regexp.MustCompile(`^https?://`)
if !reUrl.MatchString(url) && reUrl.MatchString(code) {
url, code = code, url
}
// Check whether code is already used
dburl, exists := mappings[code]
if exists {
if dburl == url {
// Trying to re-add the same url is not an error, just a noop
return code, nil
}
return code, ErrCodeExists
}
}
mappings[code] = url
err = db.writeDB(mappings)
if err != nil {
return code, err
}
return code, nil
}
// Update an existing mapping in the database, changing the URL.
func (db *DB) Update(url, code string) error {
mappings, err := db.readDB()
if err != nil {
return err
}
// Check for parameter inversion
reUrl := regexp.MustCompile(`^https?://`)
if !reUrl.MatchString(url) && reUrl.MatchString(code) {
url, code = code, url
}
// If code is missing, abort
dburl, exists := mappings[code]
if !exists {
return ErrNotFound
}
// Trying to update to the same url is not an error, just a noop
if dburl == url {
return nil
}
mappings[code] = url
err = db.writeDB(mappings)
if err != nil {
return err
}
return nil
}
// Remove the mapping with code from the database
// Returns ErrNotFound if code does not exist in the database
func (db *DB) Remove(code string) error {
mappings, err := db.readDB()
if err != nil {
return err
}
_, exists := mappings[code]
if !exists {
return ErrNotFound
}
delete(mappings, code)
err = db.writeDB(mappings)
if err != nil {
return err
}
return nil
}
// Push syncs all current mappings with the backend configured for db.Domain
// in db.ConfigPath
func (db *DB) Push() error {
config, err := db.readConfig()
if err != nil {
return err
}
if config.Type == "" {
return fmt.Errorf("no 'type' field found for %q in config %q\n",
db.Domain, db.ConfigPath)
}
switch config.Type {
case "s3":
err = db.pushS3(config)
if err != nil {
return err
}
case "render":
err = db.pushRender()
if err != nil {
return err
}
case "unconfigured":
return ErrPushTypeUnconfigured
default:
return fmt.Errorf("invalid config backend type %q found for %q: %w",
config.Type, db.Domain, ErrPushTypeBad)
}
return nil
}
// readDB is a utility function to read all mappings from db.DBPath
// and return as a go map
func (db *DB) readDB() (map[string]string, error) {
data, err := ioutil.ReadFile(db.DBPath)
if err != nil {
return nil, err
}
var mappings map[string]string
err = yaml.Unmarshal(data, &mappings)
if err != nil {
return nil, err
}
if len(mappings) == 0 {
mappings = make(map[string]string)
}
return mappings, nil
}
// writeDB is a utility function to write mappings (as yaml) to db.DBPath
func (db *DB) writeDB(mappings map[string]string) error {
var data []byte
var err error
if len(mappings) > 0 {
data, err = yaml.Marshal(mappings)
if err != nil {
return err
}
}
tmpfile := db.DBPath + ".tmp"
err = ioutil.WriteFile(tmpfile, data, 0644)
if err != nil {
return err
}
err = os.Rename(tmpfile, db.DBPath)
if err != nil {
return err
}
return nil
}
// readConfig is a utility function to read the config entry for
// db.Domain from db.ConfigPath file
func (db *DB) readConfig() (*ConfigEntry, error) {
data, err := ioutil.ReadFile(db.ConfigPath)
if err != nil {
return nil, err
}
var entries map[string]ConfigEntry
err = yaml.Unmarshal(data, &entries)
if err != nil {
return nil, err
}
entry, exists := entries[db.Domain]
if !exists {
return nil, ErrNotFound
}
return &entry, nil
}
// writeConfigString is a utility function to write data to db.ConfigPath
func (db *DB) writeConfigString(data string) error {
tmpfile := db.ConfigPath + ".tmp"
err := ioutil.WriteFile(tmpfile, []byte(data), 0600)
if err != nil {
return err
}
err = os.Rename(tmpfile, db.ConfigPath)
if err != nil {
return err
}
return nil
}
// appendConfigString is a utility function to write data to db.ConfigPath
func (db *DB) appendConfigString(data string) error {
config, err := ioutil.ReadFile(db.ConfigPath)
if err != nil {
return err
}
config = append(config, []byte(data)...)
tmpfile := db.ConfigPath + ".tmp"
err = ioutil.WriteFile(tmpfile, config, 0600)
if err != nil {
return err
}
err = os.Rename(tmpfile, db.ConfigPath)
if err != nil {
return err
}
return nil
}
// randomCode is a utility function to generate a random code
// and check that it doesn't exist in mappings.
// Random codes use the following pattern: 1 digit, then 4-7
// lowercase ascii characters. This usually allows them to be
// relatively easily distinguished from explicit codes, while
// still being easy to communicate orally.
func
|
randomCode
|
identifier_name
|
|
forall.rs
|
self.state;
let m = &mut self.max;
let mut i = 0;
loop {
if i == v.len()-1 {
|
return None;
}
if v[i] > 0 {
v[i+1] += 1;
v[i] -= 1;
if v[i+1] <= m[i+1] {
break;
}
}
i += 1;
}
let mut res = v[0..=i].iter().sum();
let mut j = 0;
while res > 0 {
let cur = std::cmp::min(m[j],res);
v[j] = cur;
res -= cur;
j += 1;
}
for k in j..=i {
v[k] = 0;
}
return Some(&self.state);
}
}
}
struct Matches {
state : Vec<Comb>,
first : bool,
v1 : Vec<usize>
}
impl Matches {
fn new(v1 : Vec<usize>, mut v2 : Vec<usize>) -> Self {
let mut s = vec![];
for &x in &v1 {
let mut c = Comb::new(x,v2.clone());
c.next();
for i in 0..v2.len() {
v2[i] -= c.state[i];
}
s.push(c);
}
Self {
v1, state : s, first : true
}
}
fn next(&mut self) -> Option<&Vec<Comb>> {
if self.first {
self.first = false;
Some(&self.state)
}else {
for i in (0..self.state.len()).rev() {
if self.state[i].next() != None {
for j in i+1..self.state.len() {
let split = self.state.split_at_mut(j);
let p = &split.0[j-1];
let p2 = &mut split.1[0];
let pmax = &p.max;
let ps = &p.state;
let n = self.v1[j];
p2.transform(n,pmax.iter().zip(ps.iter()).map(|(m,x)|m-x));
//let v : Vec<_> = pmax.iter().zip(ps.iter()).map(|(m,x)|m-x).collect();
//self.state[j] = Comb::new(n,v);
p2.next();
}
return Some(&self.state);
}
}
None
}
}
}
fn count_map<BigNum>(v : &[BigNum]) -> HashMap<BigNum,usize> where BigNum : crate::bignum::BigNum{
let mut h = HashMap::new();
for n in v {
*h.entry(n.clone()).or_default() += 1;
}
h
}
#[inline(never)]
fn intersections<BigNum>(uni : BigNum, c1 : &[(BigNum,usize)], c2 : &[(BigNum,usize)], delta : usize , bits : usize) -> Vec<Line<BigNum>> where BigNum : crate::bignum::BigNum {
let v1 : Vec<_> = c1.iter().map(|(_,c)|*c).collect();
let v2 : Vec<_> = c2.iter().map(|(_,c)|*c).collect();
let mut m = Matches::new(v1,v2);
let mut r = vec![];
let mut oldbad : Option<(usize,usize,usize,usize)> = None;
'outer: while let Some(x) = m.next() {
if let Some((i1,i2,j1,j2)) = oldbad {
if x[i1].state[j1] != 0 && x[i2].state[j2] != 0 {
continue 'outer;
}
}
for i1 in 0..c1.len() {
for j1 in 0..c2.len() {
if x[i1].state[j1] != 0 {
for i2 in i1+1..c1.len() {
for j2 in 0..c2.len() {
if x[i2].state[j2] != 0 {
let u1 = c1[i1].0.clone() & c2[j1].0.clone();
let u2 = c1[i2].0.clone() & c2[j2].0.clone();
let u3 = c1[i1].0.clone() & c2[j2].0.clone();
let u4 = c1[i2].0.clone() & c2[j1].0.clone();
if (u4.is_superset(&u1) && u3.is_superset(&u2) && (u1 != u4 || u2 != u3)) || (u3.is_superset(&u1) && u4.is_superset(&u2) && (u1 != u3 || u2 != u4)) {
oldbad = Some((i1,i2,j1,j2));
continue 'outer;
}
}
}
}
}
}
}
let mut groups = Vec::with_capacity(delta);
groups.push(uni.clone());
for (i,(ga,_)) in c1.iter().enumerate() {
for (j,(gb,_)) in c2.iter().enumerate() {
for _ in 0..x[i].state[j] {
groups.push(ga.clone() & gb.clone());
}
}
}
if !groups.contains(&BigNum::zero()) {
r.push(Line::from_groups(delta, bits, groups.into_iter()).sorted());
}
}
r
}
#[inline(never)]
fn perm_includes<BigNum>(line : &Line<BigNum>, other : &Line<BigNum>) -> bool where BigNum : crate::bignum::BigNum {
let g1 : Vec<_> = line.groups().collect();
let g2 : Vec<_> = other.groups().collect();
let d = g1.len();
let mut g = contest_algorithms::graph::flow::FlowGraph::new(2*d+2,d*d);
for i in 1..=d {
g.add_edge(0, i, 1, 0, 0);
}
for i in d+1..=2*d {
g.add_edge(i, 2*d+1, 1, 0, 0);
}
for i in 0..d {
for j in 0..d {
if g1[i].is_superset(&g2[j]) {
g.add_edge(1+i, 1+d+j, 1, 0, 0);
}
}
}
g.dinic(0, 2*d+1).0 == d as i64
}
#[inline(never)]
fn add_reduce_maximal<BigNum>(lines : &mut Vec<Line<BigNum>>, newline : Line<BigNum>) where BigNum : crate::bignum::BigNum {
let l1 = lines.len();
lines.retain(|oldline| !perm_includes(&newline, oldline));
let l2 = lines.len();
if l1 != l2 || lines.iter().all(|oldline|!perm_includes(oldline,&newline)) {
lines.push(newline);
}
}
#[inline(never)]
fn find_good_unions<BigNum>(u1 : &[BigNum], u2 : &[BigNum]) -> HashMap<BigNum,Vec<(BigNum,BigNum)>> where BigNum : crate::bignum::BigNum {
let mut unions = HashMap::new();
for x in u1.iter() {
for y in u2.iter() {
if x.is_superset(y) || y.is_superset(x) {
continue;
}
let uni = x.clone() | y.clone();
let unis : &mut Vec<(BigNum,BigNum)> = unions.entry(uni).or_insert(vec![]);
let len = unis.len();
unis.retain(|(xc,yc)| !(xc.is_superset(x) && yc.is_superset(y)) );
if unis.len() != len || unis.iter().all(|(xc,yc)| !(x.is_superset(xc) && y.is_superset(yc)) ) {
unis.push((x.clone(),y.clone()));
}
}
}
unions
}
pub fn forall<BigNum>(nc : &Constraint<BigNum>, problem : &Problem<BigNum>) -> Constraint<BigNum> where BigNum : crate::bignum::BigNum {
let mut nc = nc.clone();
let maplt = problem.map_label_text();
let set_to_string = |s:&BigNum|{
let r = s.one_bits().map(|elem|&maplt[&elem]).join("");
if r == "" {
String::from("_")
}else{
r
}
};
let make_right_closed = |g : BigNum|{g.clone()|problem.successors(g.one_bits().next().unwrap(),false)};
for line in &mut nc.lines {
*line = line.edited(|g|{make_right_closed(g)}).sorted();
}
let mut seen : HashSet<_> = nc.lines.iter().cloned().collect();
let lines = std::mem::replace(&mut nc.lines, vec![]);
for line in lines {
seen.insert(line.clone());
add_reduce
|
random_line_split
|
|
forall.rs
|
self.state;
let m = &mut self.max;
let mut i = 0;
loop {
if i == v.len()-1 {
return None;
}
if v[i] > 0 {
v[i+1] += 1;
v[i] -= 1;
if v[i+1] <= m[i+1] {
break;
}
}
i += 1;
}
let mut res = v[0..=i].iter().sum();
let mut j = 0;
while res > 0 {
let cur = std::cmp::min(m[j],res);
v[j] = cur;
res -= cur;
j += 1;
}
for k in j..=i {
v[k] = 0;
}
return Some(&self.state);
}
}
}
struct Matches {
state : Vec<Comb>,
first : bool,
v1 : Vec<usize>
}
impl Matches {
fn new(v1 : Vec<usize>, mut v2 : Vec<usize>) -> Self {
let mut s = vec![];
for &x in &v1 {
let mut c = Comb::new(x,v2.clone());
c.next();
for i in 0..v2.len() {
v2[i] -= c.state[i];
}
s.push(c);
}
Self {
v1, state : s, first : true
}
}
fn next(&mut self) -> Option<&Vec<Comb>> {
if self.first {
self.first = false;
Some(&self.state)
}else {
for i in (0..self.state.len()).rev() {
if self.state[i].next() != None {
for j in i+1..self.state.len() {
let split = self.state.split_at_mut(j);
let p = &split.0[j-1];
let p2 = &mut split.1[0];
let pmax = &p.max;
let ps = &p.state;
let n = self.v1[j];
p2.transform(n,pmax.iter().zip(ps.iter()).map(|(m,x)|m-x));
//let v : Vec<_> = pmax.iter().zip(ps.iter()).map(|(m,x)|m-x).collect();
//self.state[j] = Comb::new(n,v);
p2.next();
}
return Some(&self.state);
}
}
None
}
}
}
fn count_map<BigNum>(v : &[BigNum]) -> HashMap<BigNum,usize> where BigNum : crate::bignum::BigNum{
let mut h = HashMap::new();
for n in v {
*h.entry(n.clone()).or_default() += 1;
}
h
}
#[inline(never)]
fn intersections<BigNum>(uni : BigNum, c1 : &[(BigNum,usize)], c2 : &[(BigNum,usize)], delta : usize , bits : usize) -> Vec<Line<BigNum>> where BigNum : crate::bignum::BigNum {
let v1 : Vec<_> = c1.iter().map(|(_,c)|*c).collect();
let v2 : Vec<_> = c2.iter().map(|(_,c)|*c).collect();
let mut m = Matches::new(v1,v2);
let mut r = vec![];
let mut oldbad : Option<(usize,usize,usize,usize)> = None;
'outer: while let Some(x) = m.next() {
if let Some((i1,i2,j1,j2)) = oldbad {
if x[i1].state[j1] != 0 && x[i2].state[j2] != 0 {
continue 'outer;
}
}
for i1 in 0..c1.len() {
for j1 in 0..c2.len() {
if x[i1].state[j1] != 0 {
for i2 in i1+1..c1.len() {
for j2 in 0..c2.len() {
if x[i2].state[j2] != 0
|
}
}
}
}
}
let mut groups = Vec::with_capacity(delta);
groups.push(uni.clone());
for (i,(ga,_)) in c1.iter().enumerate() {
for (j,(gb,_)) in c2.iter().enumerate() {
for _ in 0..x[i].state[j] {
groups.push(ga.clone() & gb.clone());
}
}
}
if !groups.contains(&BigNum::zero()) {
r.push(Line::from_groups(delta, bits, groups.into_iter()).sorted());
}
}
r
}
#[inline(never)]
fn perm_includes<BigNum>(line : &Line<BigNum>, other : &Line<BigNum>) -> bool where BigNum : crate::bignum::BigNum {
let g1 : Vec<_> = line.groups().collect();
let g2 : Vec<_> = other.groups().collect();
let d = g1.len();
let mut g = contest_algorithms::graph::flow::FlowGraph::new(2*d+2,d*d);
for i in 1..=d {
g.add_edge(0, i, 1, 0, 0);
}
for i in d+1..=2*d {
g.add_edge(i, 2*d+1, 1, 0, 0);
}
for i in 0..d {
for j in 0..d {
if g1[i].is_superset(&g2[j]) {
g.add_edge(1+i, 1+d+j, 1, 0, 0);
}
}
}
g.dinic(0, 2*d+1).0 == d as i64
}
#[inline(never)]
fn add_reduce_maximal<BigNum>(lines : &mut Vec<Line<BigNum>>, newline : Line<BigNum>) where BigNum : crate::bignum::BigNum {
let l1 = lines.len();
lines.retain(|oldline| !perm_includes(&newline, oldline));
let l2 = lines.len();
if l1 != l2 || lines.iter().all(|oldline|!perm_includes(oldline,&newline)) {
lines.push(newline);
}
}
#[inline(never)]
fn find_good_unions<BigNum>(u1 : &[BigNum], u2 : &[BigNum]) -> HashMap<BigNum,Vec<(BigNum,BigNum)>> where BigNum : crate::bignum::BigNum {
let mut unions = HashMap::new();
for x in u1.iter() {
for y in u2.iter() {
if x.is_superset(y) || y.is_superset(x) {
continue;
}
let uni = x.clone() | y.clone();
let unis : &mut Vec<(BigNum,BigNum)> = unions.entry(uni).or_insert(vec![]);
let len = unis.len();
unis.retain(|(xc,yc)| !(xc.is_superset(x) && yc.is_superset(y)) );
if unis.len() != len || unis.iter().all(|(xc,yc)| !(x.is_superset(xc) && y.is_superset(yc)) ) {
unis.push((x.clone(),y.clone()));
}
}
}
unions
}
pub fn forall<BigNum>(nc : &Constraint<BigNum>, problem : &Problem<BigNum>) -> Constraint<BigNum> where BigNum : crate::bignum::BigNum {
let mut nc = nc.clone();
let maplt = problem.map_label_text();
let set_to_string = |s:&BigNum|{
let r = s.one_bits().map(|elem|&maplt[&elem]).join("");
if r == "" {
String::from("_")
}else{
r
}
};
let make_right_closed = |g : BigNum|{g.clone()|problem.successors(g.one_bits().next().unwrap(),false)};
for line in &mut nc.lines {
*line = line.edited(|g|{make_right_closed(g)}).sorted();
}
let mut seen : HashSet<_> = nc.lines.iter().cloned().collect();
let lines = std::mem::replace(&mut nc.lines, vec![]);
for line in lines {
seen.insert(line.clone());
|
{
let u1 = c1[i1].0.clone() & c2[j1].0.clone();
let u2 = c1[i2].0.clone() & c2[j2].0.clone();
let u3 = c1[i1].0.clone() & c2[j2].0.clone();
let u4 = c1[i2].0.clone() & c2[j1].0.clone();
if (u4.is_superset(&u1) && u3.is_superset(&u2) && (u1 != u4 || u2 != u3)) || (u3.is_superset(&u1) && u4.is_superset(&u2) && (u1 != u3 || u2 != u4)) {
oldbad = Some((i1,i2,j1,j2));
continue 'outer;
}
}
|
conditional_block
|
forall.rs
|
fn transform(&mut self, n : usize, max : impl Iterator<Item=usize>) {
let mut i = 0;
for x in max {
self.max[i] = x;
i += 1;
}
assert!(i == self.max.len());
let mut res = n;
let mut i = 0;
while res > 0 {
let cur = std::cmp::min(self.max[i],res);
self.state[i] = cur;
res -= cur;
i += 1;
}
for j in i..self.state.len() {
self.state[j] = 0;
}
self.first = true;
}
fn next(&mut self) -> Option<&Vec<usize>> {
if self.first {
self.first = false;
Some(&self.state)
}else {
let v = &mut self.state;
let m = &mut self.max;
let mut i = 0;
loop {
if i == v.len()-1 {
return None;
}
if v[i] > 0 {
v[i+1] += 1;
v[i] -= 1;
if v[i+1] <= m[i+1] {
break;
}
}
i += 1;
}
let mut res = v[0..=i].iter().sum();
let mut j = 0;
while res > 0 {
let cur = std::cmp::min(m[j],res);
v[j] = cur;
res -= cur;
j += 1;
}
for k in j..=i {
v[k] = 0;
}
return Some(&self.state);
}
}
}
struct Matches {
state : Vec<Comb>,
first : bool,
v1 : Vec<usize>
}
impl Matches {
fn new(v1 : Vec<usize>, mut v2 : Vec<usize>) -> Self {
let mut s = vec![];
for &x in &v1 {
let mut c = Comb::new(x,v2.clone());
c.next();
for i in 0..v2.len() {
v2[i] -= c.state[i];
}
s.push(c);
}
Self {
v1, state : s, first : true
}
}
fn next(&mut self) -> Option<&Vec<Comb>> {
if self.first {
self.first = false;
Some(&self.state)
}else {
for i in (0..self.state.len()).rev() {
if self.state[i].next() != None {
for j in i+1..self.state.len() {
let split = self.state.split_at_mut(j);
let p = &split.0[j-1];
let p2 = &mut split.1[0];
let pmax = &p.max;
let ps = &p.state;
let n = self.v1[j];
p2.transform(n,pmax.iter().zip(ps.iter()).map(|(m,x)|m-x));
//let v : Vec<_> = pmax.iter().zip(ps.iter()).map(|(m,x)|m-x).collect();
//self.state[j] = Comb::new(n,v);
p2.next();
}
return Some(&self.state);
}
}
None
}
}
}
fn count_map<BigNum>(v : &[BigNum]) -> HashMap<BigNum,usize> where BigNum : crate::bignum::BigNum{
let mut h = HashMap::new();
for n in v {
*h.entry(n.clone()).or_default() += 1;
}
h
}
#[inline(never)]
fn intersections<BigNum>(uni : BigNum, c1 : &[(BigNum,usize)], c2 : &[(BigNum,usize)], delta : usize , bits : usize) -> Vec<Line<BigNum>> where BigNum : crate::bignum::BigNum {
let v1 : Vec<_> = c1.iter().map(|(_,c)|*c).collect();
let v2 : Vec<_> = c2.iter().map(|(_,c)|*c).collect();
let mut m = Matches::new(v1,v2);
let mut r = vec![];
let mut oldbad : Option<(usize,usize,usize,usize)> = None;
'outer: while let Some(x) = m.next() {
if let Some((i1,i2,j1,j2)) = oldbad {
if x[i1].state[j1] != 0 && x[i2].state[j2] != 0 {
continue 'outer;
}
}
for i1 in 0..c1.len() {
for j1 in 0..c2.len() {
if x[i1].state[j1] != 0 {
for i2 in i1+1..c1.len() {
for j2 in 0..c2.len() {
if x[i2].state[j2] != 0 {
let u1 = c1[i1].0.clone() & c2[j1].0.clone();
let u2 = c1[i2].0.clone() & c2[j2].0.clone();
let u3 = c1[i1].0.clone() & c2[j2].0.clone();
let u4 = c1[i2].0.clone() & c2[j1].0.clone();
if (u4.is_superset(&u1) && u3.is_superset(&u2) && (u1 != u4 || u2 != u3)) || (u3.is_superset(&u1) && u4.is_superset(&u2) && (u1 != u3 || u2 != u4)) {
oldbad = Some((i1,i2,j1,j2));
continue 'outer;
}
}
}
}
}
}
}
let mut groups = Vec::with_capacity(delta);
groups.push(uni.clone());
for (i,(ga,_)) in c1.iter().enumerate() {
for (j,(gb,_)) in c2.iter().enumerate() {
for _ in 0..x[i].state[j] {
groups.push(ga.clone() & gb.clone());
}
}
}
if !groups.contains(&BigNum::zero()) {
r.push(Line::from_groups(delta, bits, groups.into_iter()).sorted());
}
}
r
}
#[inline(never)]
fn perm_includes<BigNum>(line : &Line<BigNum>, other : &Line<BigNum>) -> bool where BigNum : crate::bignum::BigNum {
let g1 : Vec<_> = line.groups().collect();
let g2 : Vec<_> = other.groups().collect();
let d = g1.len();
let mut g = contest_algorithms::graph::flow::FlowGraph::new(2*d+2,d*d);
for i in 1..=d {
g.add_edge(0, i, 1, 0, 0);
}
for i in d+1..=2*d {
g.add_edge(i, 2*d+1, 1, 0, 0);
}
for i in 0..d {
for j in 0..d {
if g1[i].is_superset(&g2[j]) {
g.add_edge(1+i, 1+d+j, 1, 0, 0);
}
}
}
g.dinic(0, 2*d+1).0 == d as i64
}
#[inline(never)]
fn add_reduce_maximal<BigNum>(lines : &mut Vec<Line<BigNum>>, newline : Line<BigNum>) where BigNum : crate::bignum::BigNum {
let l1 = lines.len();
lines.retain(|oldline| !perm_includes(&newline, oldline));
let l2 = lines.len();
if l1 != l2 || lines.iter().all(|oldline|!perm_includes(oldline,&newline)) {
lines.push(newline);
}
}
#[inline(never)]
fn find_good_unions<BigNum>(u1 : &[BigNum], u2 : &[BigNum]) -> HashMap<BigNum,Vec<(BigNum,BigNum)>> where BigNum : crate::bignum::BigNum {
let mut unions = HashMap::new();
for x in u1.iter() {
for y in u2.iter() {
if x.is_superset(y) || y.is_superset(x) {
continue;
}
let uni = x.clone() | y.clone();
let unis : &mut Vec<(BigNum,BigNum)> = unions.entry(uni).or_insert(vec![]);
let len = unis.len();
unis.retain(|(xc,yc)| !(xc.is_superset(x) && yc.is_superset(y)) );
if unis.len() != len || unis
|
{
let mut state = vec![0;max.len()];
let mut res = n;
let mut i = 0;
while res > 0 {
let cur = std::cmp::min(max[i],res);
state[i] = cur;
res -= cur;
i += 1;
}
Comb {
max, state, first:true
}
}
|
identifier_body
|
|
forall.rs
|
self.state;
let m = &mut self.max;
let mut i = 0;
loop {
if i == v.len()-1 {
return None;
}
if v[i] > 0 {
v[i+1] += 1;
v[i] -= 1;
if v[i+1] <= m[i+1] {
break;
}
}
i += 1;
}
let mut res = v[0..=i].iter().sum();
let mut j = 0;
while res > 0 {
let cur = std::cmp::min(m[j],res);
v[j] = cur;
res -= cur;
j += 1;
}
for k in j..=i {
v[k] = 0;
}
return Some(&self.state);
}
}
}
struct
|
{
state : Vec<Comb>,
first : bool,
v1 : Vec<usize>
}
impl Matches {
fn new(v1 : Vec<usize>, mut v2 : Vec<usize>) -> Self {
let mut s = vec![];
for &x in &v1 {
let mut c = Comb::new(x,v2.clone());
c.next();
for i in 0..v2.len() {
v2[i] -= c.state[i];
}
s.push(c);
}
Self {
v1, state : s, first : true
}
}
fn next(&mut self) -> Option<&Vec<Comb>> {
if self.first {
self.first = false;
Some(&self.state)
}else {
for i in (0..self.state.len()).rev() {
if self.state[i].next() != None {
for j in i+1..self.state.len() {
let split = self.state.split_at_mut(j);
let p = &split.0[j-1];
let p2 = &mut split.1[0];
let pmax = &p.max;
let ps = &p.state;
let n = self.v1[j];
p2.transform(n,pmax.iter().zip(ps.iter()).map(|(m,x)|m-x));
//let v : Vec<_> = pmax.iter().zip(ps.iter()).map(|(m,x)|m-x).collect();
//self.state[j] = Comb::new(n,v);
p2.next();
}
return Some(&self.state);
}
}
None
}
}
}
fn count_map<BigNum>(v : &[BigNum]) -> HashMap<BigNum,usize> where BigNum : crate::bignum::BigNum{
let mut h = HashMap::new();
for n in v {
*h.entry(n.clone()).or_default() += 1;
}
h
}
#[inline(never)]
fn intersections<BigNum>(uni : BigNum, c1 : &[(BigNum,usize)], c2 : &[(BigNum,usize)], delta : usize , bits : usize) -> Vec<Line<BigNum>> where BigNum : crate::bignum::BigNum {
let v1 : Vec<_> = c1.iter().map(|(_,c)|*c).collect();
let v2 : Vec<_> = c2.iter().map(|(_,c)|*c).collect();
let mut m = Matches::new(v1,v2);
let mut r = vec![];
let mut oldbad : Option<(usize,usize,usize,usize)> = None;
'outer: while let Some(x) = m.next() {
if let Some((i1,i2,j1,j2)) = oldbad {
if x[i1].state[j1] != 0 && x[i2].state[j2] != 0 {
continue 'outer;
}
}
for i1 in 0..c1.len() {
for j1 in 0..c2.len() {
if x[i1].state[j1] != 0 {
for i2 in i1+1..c1.len() {
for j2 in 0..c2.len() {
if x[i2].state[j2] != 0 {
let u1 = c1[i1].0.clone() & c2[j1].0.clone();
let u2 = c1[i2].0.clone() & c2[j2].0.clone();
let u3 = c1[i1].0.clone() & c2[j2].0.clone();
let u4 = c1[i2].0.clone() & c2[j1].0.clone();
if (u4.is_superset(&u1) && u3.is_superset(&u2) && (u1 != u4 || u2 != u3)) || (u3.is_superset(&u1) && u4.is_superset(&u2) && (u1 != u3 || u2 != u4)) {
oldbad = Some((i1,i2,j1,j2));
continue 'outer;
}
}
}
}
}
}
}
let mut groups = Vec::with_capacity(delta);
groups.push(uni.clone());
for (i,(ga,_)) in c1.iter().enumerate() {
for (j,(gb,_)) in c2.iter().enumerate() {
for _ in 0..x[i].state[j] {
groups.push(ga.clone() & gb.clone());
}
}
}
if !groups.contains(&BigNum::zero()) {
r.push(Line::from_groups(delta, bits, groups.into_iter()).sorted());
}
}
r
}
#[inline(never)]
fn perm_includes<BigNum>(line : &Line<BigNum>, other : &Line<BigNum>) -> bool where BigNum : crate::bignum::BigNum {
let g1 : Vec<_> = line.groups().collect();
let g2 : Vec<_> = other.groups().collect();
let d = g1.len();
let mut g = contest_algorithms::graph::flow::FlowGraph::new(2*d+2,d*d);
for i in 1..=d {
g.add_edge(0, i, 1, 0, 0);
}
for i in d+1..=2*d {
g.add_edge(i, 2*d+1, 1, 0, 0);
}
for i in 0..d {
for j in 0..d {
if g1[i].is_superset(&g2[j]) {
g.add_edge(1+i, 1+d+j, 1, 0, 0);
}
}
}
g.dinic(0, 2*d+1).0 == d as i64
}
#[inline(never)]
fn add_reduce_maximal<BigNum>(lines : &mut Vec<Line<BigNum>>, newline : Line<BigNum>) where BigNum : crate::bignum::BigNum {
let l1 = lines.len();
lines.retain(|oldline| !perm_includes(&newline, oldline));
let l2 = lines.len();
if l1 != l2 || lines.iter().all(|oldline|!perm_includes(oldline,&newline)) {
lines.push(newline);
}
}
#[inline(never)]
fn find_good_unions<BigNum>(u1 : &[BigNum], u2 : &[BigNum]) -> HashMap<BigNum,Vec<(BigNum,BigNum)>> where BigNum : crate::bignum::BigNum {
let mut unions = HashMap::new();
for x in u1.iter() {
for y in u2.iter() {
if x.is_superset(y) || y.is_superset(x) {
continue;
}
let uni = x.clone() | y.clone();
let unis : &mut Vec<(BigNum,BigNum)> = unions.entry(uni).or_insert(vec![]);
let len = unis.len();
unis.retain(|(xc,yc)| !(xc.is_superset(x) && yc.is_superset(y)) );
if unis.len() != len || unis.iter().all(|(xc,yc)| !(x.is_superset(xc) && y.is_superset(yc)) ) {
unis.push((x.clone(),y.clone()));
}
}
}
unions
}
pub fn forall<BigNum>(nc : &Constraint<BigNum>, problem : &Problem<BigNum>) -> Constraint<BigNum> where BigNum : crate::bignum::BigNum {
let mut nc = nc.clone();
let maplt = problem.map_label_text();
let set_to_string = |s:&BigNum|{
let r = s.one_bits().map(|elem|&maplt[&elem]).join("");
if r == "" {
String::from("_")
}else{
r
}
};
let make_right_closed = |g : BigNum|{g.clone()|problem.successors(g.one_bits().next().unwrap(),false)};
for line in &mut nc.lines {
*line = line.edited(|g|{make_right_closed(g)}).sorted();
}
let mut seen : HashSet<_> = nc.lines.iter().cloned().collect();
let lines = std::mem::replace(&mut nc.lines, vec![]);
for line in lines {
seen.insert(line.clone());
add
|
Matches
|
identifier_name
|
api_op_CreateFleet.go
|
type CreateFleetInput struct {
// A descriptive label that is associated with a fleet. Fleet names do not need to
// be unique.
//
// This member is required.
Name *string
// Amazon GameLift Anywhere configuration options.
AnywhereConfiguration *types.AnywhereConfiguration
// The unique identifier for a custom game server build to be deployed on fleet
// instances. You can use either the build ID or ARN. The build must be uploaded to
// Amazon GameLift and in READY status. This fleet property cannot be changed
// later.
BuildId *string
// Prompts Amazon GameLift to generate a TLS/SSL certificate for the fleet. Amazon
// GameLift uses the certificates to encrypt traffic between game clients and the
// game servers running on Amazon GameLift. By default, the
// CertificateConfiguration is DISABLED . You can't change this property after you
// create the fleet. Certificate Manager (ACM) certificates expire after 13 months.
// Certificate expiration can cause fleets to fail, preventing players from
// connecting to instances in the fleet. We recommend you replace fleets before 13
// months, consider using fleet aliases for a smooth transition. ACM isn't
// available in all Amazon Web Services regions. A fleet creation request with
// certificate generation enabled in an unsupported Region, fails with a 4xx error.
// For more information about the supported Regions, see Supported Regions (https://docs.aws.amazon.com/acm/latest/userguide/acm-regions.html)
// in the Certificate Manager User Guide.
CertificateConfiguration *types.CertificateConfiguration
// The type of compute resource used to host your game servers. You can use your
// own compute resources with Amazon GameLift Anywhere or use Amazon EC2 instances
// with managed Amazon GameLift. By default, this property is set to EC2 .
ComputeType types.ComputeType
// A description for the fleet.
Description *string
// The allowed IP address ranges and port settings that allow inbound traffic to
// access game sessions on this fleet. If the fleet is hosting a custom game build,
// this property must be set before players can connect to game sessions. For
// Realtime Servers fleets, Amazon GameLift automatically sets TCP and UDP ranges.
EC2InboundPermissions []types.IpPermission
// The Amazon GameLift-supported Amazon EC2 instance type to use for all fleet
// instances. Instance type determines the computing resources that will be used to
// host your game servers, including CPU, memory, storage, and networking capacity.
// See Amazon Elastic Compute Cloud Instance Types (http://aws.amazon.com/ec2/instance-types/)
// for detailed descriptions of Amazon EC2 instance types.
EC2InstanceType types.EC2InstanceType
// Indicates whether to use On-Demand or Spot instances for this fleet. By
// default, this property is set to ON_DEMAND . Learn more about when to use
// On-Demand versus Spot Instances (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot)
// . This property cannot be changed after the fleet is created.
FleetType types.FleetType
// A unique identifier for an IAM role that manages access to your Amazon Web
// Services services. With an instance role ARN set, any application that runs on
// an instance in this fleet can assume the role, including install scripts, server
// processes, and daemons (background processes). Create a role or look up a role's
// ARN by using the IAM dashboard (https://console.aws.amazon.com/iam/) in the
// Amazon Web Services Management Console. Learn more about using on-box
// credentials for your game servers at Access external resources from a game
// server (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-resources.html)
// . This property cannot be changed after the fleet is created.
InstanceRoleArn *string
// A set of remote locations to deploy additional instances to and manage as part
// of the fleet. This parameter can only be used when creating fleets in Amazon Web
// Services Regions that support multiple locations. You can add any Amazon
// GameLift-supported Amazon Web Services Region as a remote location, in the form
// of an Amazon Web Services Region code such as us-west-2 . To create a fleet with
// instances in the home Region only, don't use this parameter. To use this
// parameter, Amazon GameLift requires you to use your home location in the
// request.
Locations []types.LocationConfiguration
// This parameter is no longer used. To specify where Amazon GameLift should store
// log files once a server process shuts down, use the Amazon GameLift server API
// ProcessReady() and specify one or more directory paths in logParameters . For
// more information, see Initialize the server process (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-initialize)
// in the Amazon GameLift Developer Guide.
LogPaths []string
// The name of an Amazon Web Services CloudWatch metric group to add this fleet
// to. A metric group is used to aggregate the metrics for multiple fleets. You can
// specify an existing metric group name or set a new name to create a new metric
// group. A fleet can be included in only one metric group at a time.
MetricGroups []string
// The status of termination protection for active game sessions on the fleet. By
// default, this property is set to NoProtection . You can also set game session
// protection for an individual game session by calling UpdateGameSession .
// - NoProtection - Game sessions can be terminated during active gameplay as a
// result of a scale-down event.
// - FullProtection - Game sessions in ACTIVE status cannot be terminated during
// a scale-down event.
NewGameSessionProtectionPolicy types.ProtectionPolicy
// Used when peering your Amazon GameLift fleet with a VPC, the unique identifier
// for the Amazon Web Services account that owns the VPC. You can find your account
// ID in the Amazon Web Services Management Console under account settings.
PeerVpcAwsAccountId *string
// A unique identifier for a VPC with resources to be accessed by your Amazon
// GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
// VPC ID, use the VPC Dashboard (https://console.aws.amazon.com/vpc/) in the
// Amazon Web Services Management Console. Learn more about VPC peering in VPC
// Peering with Amazon GameLift Fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html)
// .
PeerVpcId *string
// A policy that limits the number of game sessions that an individual player can
// create on instances in this fleet within a specified span of time.
ResourceCreationLimitPolicy *types.ResourceCreationLimitPolicy
// Instructions for how to launch and maintain server processes on instances in
// the fleet. The runtime configuration defines one or more server process
// configurations, each identifying a build executable or Realtime script file and
// the number of processes of that type to run concurrently. The
// RuntimeConfiguration parameter is required unless the fleet is being configured
// using the older parameters ServerLaunchPath and ServerLaunchParameters , which
// are still supported for backward compatibility.
RuntimeConfiguration *types.RuntimeConfiguration
// The unique identifier for a Realtime configuration script to be deployed on
// fleet instances. You can use either the script ID or ARN. Scripts must be
// uploaded to Amazon GameLift prior to creating the fleet. This fleet property
// cannot be changed later.
ScriptId *string
// This parameter is no longer used. Specify server launch parameters using the
// RuntimeConfiguration parameter. Requests that use this parameter instead
// continue to be valid.
ServerLaunchParameters *string
// This parameter is no longer used. Specify a server launch path using the
// RuntimeConfiguration parameter. Requests that use this parameter instead
// continue to be valid.
ServerLaunchPath *string
// A list of labels to assign to the new fleet resource. Tags are
// developer-defined key-value pairs. Tagging Amazon Web Services resources are
// useful for resource management, access management and cost allocation. For more
// information, see Tagging Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// in the Amazon Web Services General Reference.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateFleetOutput struct {
// The properties for the new fleet, including the current status. All fleets are
// placed in NEW status on creation.
|
{
if params == nil {
params = &CreateFleetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateFleet", params, optFns, c.addOperationCreateFleetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateFleetOutput)
out.ResultMetadata = metadata
return out, nil
}
|
identifier_body
|
|
api_op_CreateFleet.go
|
// computing resources for your fleet and provide instructions for running game
// servers on each instance. Most Amazon GameLift fleets can deploy instances to
// multiple locations, including the home Region (where the fleet is created) and
// an optional set of remote locations. Fleets that are created in the following
// Amazon Web Services Regions support multiple locations: us-east-1 (N. Virginia),
// us-west-2 (Oregon), eu-central-1 (Frankfurt), eu-west-1 (Ireland),
// ap-southeast-2 (Sydney), ap-northeast-1 (Tokyo), and ap-northeast-2 (Seoul).
// Fleets that are created in other Amazon GameLift Regions can deploy instances in
// the fleet's home Region only. All fleet instances use the same configuration
// regardless of location; however, you can adjust capacity settings and turn
// auto-scaling on/off for each location. To create a fleet, choose the hardware
// for your instances, specify a game server build or Realtime script to deploy,
// and provide a runtime configuration to direct Amazon GameLift how to start and
// run game servers on each instance in the fleet. Set permissions for inbound
// traffic to your game servers, and enable optional features as needed. When
// creating a multi-location fleet, provide a list of additional remote locations.
// If you need to debug your fleet, fetch logs, view performance metrics or other
// actions on the fleet, create the development fleet with port 22/3389 open. As a
// best practice, we recommend opening ports for remote access only when you need
// them and closing them when you're finished. If successful, this operation
// creates a new Fleet resource and places it in NEW status, which prompts Amazon
// GameLift to initiate the fleet creation workflow (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-all.html#fleets-creation-workflow)
// . Learn more Setting up fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
// Debug fleet creation issues (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-debug.html#fleets-creating-debug-creation)
// Multi-location fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) CreateFleet(ctx context.Context, params *CreateFleetInput, optFns ...func(*Options)) (*CreateFleetOutput, error) {
if params == nil {
params = &CreateFleetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateFleet", params, optFns, c.addOperationCreateFleetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateFleetOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateFleetInput struct {
// A descriptive label that is associated with a fleet. Fleet names do not need to
// be unique.
//
// This member is required.
Name *string
// Amazon GameLift Anywhere configuration options.
AnywhereConfiguration *types.AnywhereConfiguration
// The unique identifier for a custom game server build to be deployed on fleet
// instances. You can use either the build ID or ARN. The build must be uploaded to
// Amazon GameLift and in READY status. This fleet property cannot be changed
// later.
BuildId *string
// Prompts Amazon GameLift to generate a TLS/SSL certificate for the fleet. Amazon
// GameLift uses the certificates to encrypt traffic between game clients and the
// game servers running on Amazon GameLift. By default, the
// CertificateConfiguration is DISABLED . You can't change this property after you
// create the fleet. Certificate Manager (ACM) certificates expire after 13 months.
// Certificate expiration can cause fleets to fail, preventing players from
// connecting to instances in the fleet. We recommend you replace fleets before 13
// months, consider using fleet aliases for a smooth transition. ACM isn't
// available in all Amazon Web Services regions. A fleet creation request with
// certificate generation enabled in an unsupported Region, fails with a 4xx error.
// For more information about the supported Regions, see Supported Regions (https://docs.aws.amazon.com/acm/latest/userguide/acm-regions.html)
// in the Certificate Manager User Guide.
CertificateConfiguration *types.CertificateConfiguration
// The type of compute resource used to host your game servers. You can use your
// own compute resources with Amazon GameLift Anywhere or use Amazon EC2 instances
// with managed Amazon GameLift. By default, this property is set to EC2 .
ComputeType types.ComputeType
// A description for the fleet.
Description *string
// The allowed IP address ranges and port settings that allow inbound traffic to
// access game sessions on this fleet. If the fleet is hosting a custom game build,
// this property must be set before players can connect to game sessions. For
// Realtime Servers fleets, Amazon GameLift automatically sets TCP and UDP ranges.
EC2InboundPermissions []types.IpPermission
// The Amazon GameLift-supported Amazon EC2 instance type to use for all fleet
// instances. Instance type determines the computing resources that will be used to
// host your game servers, including CPU, memory, storage, and networking capacity.
// See Amazon Elastic Compute Cloud Instance Types (http://aws.amazon.com/ec2/instance-types/)
// for detailed descriptions of Amazon EC2 instance types.
EC2InstanceType types.EC2InstanceType
// Indicates whether to use On-Demand or Spot instances for this fleet. By
// default, this property is set to ON_DEMAND . Learn more about when to use
// On-Demand versus Spot Instances (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot)
// . This property cannot be changed after the fleet is created.
FleetType types.FleetType
// A unique identifier for an IAM role that manages access to your Amazon Web
// Services services. With an instance role ARN set, any application that runs on
// an instance in this fleet can assume the role, including install scripts, server
// processes, and daemons (background processes). Create a role or look up a role's
// ARN by using the IAM dashboard (https://console.aws.amazon.com/iam/) in the
// Amazon Web Services Management Console. Learn more about using on-box
// credentials for your game servers at Access external resources from a game
// server (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-resources.html)
// . This property cannot be changed after the fleet is created.
InstanceRoleArn *string
// A set of remote locations to deploy additional instances to and manage as part
// of the fleet. This parameter can only be used when creating fleets in Amazon Web
// Services Regions that support multiple locations. You can add any Amazon
// GameLift-supported Amazon Web Services Region as a remote location, in the form
// of an Amazon Web Services Region code such as us-west-2 . To create a fleet with
// instances in the home Region only, don't use this parameter. To use this
// parameter, Amazon GameLift requires you to use your home location in the
// request.
Locations []types.LocationConfiguration
// This parameter is no longer used. To specify where Amazon GameLift should store
// log files once a server process shuts down, use the Amazon GameLift server API
// ProcessReady() and specify one or more directory paths in logParameters . For
// more information, see Initialize the server process (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-initialize)
// in the Amazon GameLift Developer Guide.
LogPaths []string
// The name of an Amazon Web Services CloudWatch metric group to add this fleet
// to. A metric group is used to aggregate the metrics for multiple fleets. You can
// specify an existing metric group name or set a new name to create a new metric
// group. A fleet can be included in only one metric group at a time.
MetricGroups []string
// The status of termination protection for active game sessions on the fleet. By
// default, this property is set to NoProtection . You can also set game session
// protection for an individual game session by calling UpdateGameSession .
// - NoProtection - Game sessions can be terminated during active gameplay as a
// result of a scale-down event.
// - FullProtection - Game sessions in ACTIVE status cannot be terminated during
// a scale-down event.
NewGameSessionProtectionPolicy types.ProtectionPolicy
// Used when peering your Amazon GameLift fleet with a VPC, the unique identifier
// for the Amazon Web Services account that owns the VPC. You can find your account
// ID in the
|
)
// Creates a fleet of Amazon Elastic Compute Cloud (Amazon EC2) instances to host
// your custom game server or Realtime Servers. Use this operation to configure the
|
random_line_split
|
|
api_op_CreateFleet.go
|
READY status. This fleet property cannot be changed
// later.
BuildId *string
// Prompts Amazon GameLift to generate a TLS/SSL certificate for the fleet. Amazon
// GameLift uses the certificates to encrypt traffic between game clients and the
// game servers running on Amazon GameLift. By default, the
// CertificateConfiguration is DISABLED . You can't change this property after you
// create the fleet. Certificate Manager (ACM) certificates expire after 13 months.
// Certificate expiration can cause fleets to fail, preventing players from
// connecting to instances in the fleet. We recommend you replace fleets before 13
// months, consider using fleet aliases for a smooth transition. ACM isn't
// available in all Amazon Web Services regions. A fleet creation request with
// certificate generation enabled in an unsupported Region, fails with a 4xx error.
// For more information about the supported Regions, see Supported Regions (https://docs.aws.amazon.com/acm/latest/userguide/acm-regions.html)
// in the Certificate Manager User Guide.
CertificateConfiguration *types.CertificateConfiguration
// The type of compute resource used to host your game servers. You can use your
// own compute resources with Amazon GameLift Anywhere or use Amazon EC2 instances
// with managed Amazon GameLift. By default, this property is set to EC2 .
ComputeType types.ComputeType
// A description for the fleet.
Description *string
// The allowed IP address ranges and port settings that allow inbound traffic to
// access game sessions on this fleet. If the fleet is hosting a custom game build,
// this property must be set before players can connect to game sessions. For
// Realtime Servers fleets, Amazon GameLift automatically sets TCP and UDP ranges.
EC2InboundPermissions []types.IpPermission
// The Amazon GameLift-supported Amazon EC2 instance type to use for all fleet
// instances. Instance type determines the computing resources that will be used to
// host your game servers, including CPU, memory, storage, and networking capacity.
// See Amazon Elastic Compute Cloud Instance Types (http://aws.amazon.com/ec2/instance-types/)
// for detailed descriptions of Amazon EC2 instance types.
EC2InstanceType types.EC2InstanceType
// Indicates whether to use On-Demand or Spot instances for this fleet. By
// default, this property is set to ON_DEMAND . Learn more about when to use
// On-Demand versus Spot Instances (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot)
// . This property cannot be changed after the fleet is created.
FleetType types.FleetType
// A unique identifier for an IAM role that manages access to your Amazon Web
// Services services. With an instance role ARN set, any application that runs on
// an instance in this fleet can assume the role, including install scripts, server
// processes, and daemons (background processes). Create a role or look up a role's
// ARN by using the IAM dashboard (https://console.aws.amazon.com/iam/) in the
// Amazon Web Services Management Console. Learn more about using on-box
// credentials for your game servers at Access external resources from a game
// server (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-resources.html)
// . This property cannot be changed after the fleet is created.
InstanceRoleArn *string
// A set of remote locations to deploy additional instances to and manage as part
// of the fleet. This parameter can only be used when creating fleets in Amazon Web
// Services Regions that support multiple locations. You can add any Amazon
// GameLift-supported Amazon Web Services Region as a remote location, in the form
// of an Amazon Web Services Region code such as us-west-2 . To create a fleet with
// instances in the home Region only, don't use this parameter. To use this
// parameter, Amazon GameLift requires you to use your home location in the
// request.
Locations []types.LocationConfiguration
// This parameter is no longer used. To specify where Amazon GameLift should store
// log files once a server process shuts down, use the Amazon GameLift server API
// ProcessReady() and specify one or more directory paths in logParameters . For
// more information, see Initialize the server process (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-initialize)
// in the Amazon GameLift Developer Guide.
LogPaths []string
// The name of an Amazon Web Services CloudWatch metric group to add this fleet
// to. A metric group is used to aggregate the metrics for multiple fleets. You can
// specify an existing metric group name or set a new name to create a new metric
// group. A fleet can be included in only one metric group at a time.
MetricGroups []string
// The status of termination protection for active game sessions on the fleet. By
// default, this property is set to NoProtection . You can also set game session
// protection for an individual game session by calling UpdateGameSession .
// - NoProtection - Game sessions can be terminated during active gameplay as a
// result of a scale-down event.
// - FullProtection - Game sessions in ACTIVE status cannot be terminated during
// a scale-down event.
NewGameSessionProtectionPolicy types.ProtectionPolicy
// Used when peering your Amazon GameLift fleet with a VPC, the unique identifier
// for the Amazon Web Services account that owns the VPC. You can find your account
// ID in the Amazon Web Services Management Console under account settings.
PeerVpcAwsAccountId *string
// A unique identifier for a VPC with resources to be accessed by your Amazon
// GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
// VPC ID, use the VPC Dashboard (https://console.aws.amazon.com/vpc/) in the
// Amazon Web Services Management Console. Learn more about VPC peering in VPC
// Peering with Amazon GameLift Fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html)
// .
PeerVpcId *string
// A policy that limits the number of game sessions that an individual player can
// create on instances in this fleet within a specified span of time.
ResourceCreationLimitPolicy *types.ResourceCreationLimitPolicy
// Instructions for how to launch and maintain server processes on instances in
// the fleet. The runtime configuration defines one or more server process
// configurations, each identifying a build executable or Realtime script file and
// the number of processes of that type to run concurrently. The
// RuntimeConfiguration parameter is required unless the fleet is being configured
// using the older parameters ServerLaunchPath and ServerLaunchParameters , which
// are still supported for backward compatibility.
RuntimeConfiguration *types.RuntimeConfiguration
// The unique identifier for a Realtime configuration script to be deployed on
// fleet instances. You can use either the script ID or ARN. Scripts must be
// uploaded to Amazon GameLift prior to creating the fleet. This fleet property
// cannot be changed later.
ScriptId *string
// This parameter is no longer used. Specify server launch parameters using the
// RuntimeConfiguration parameter. Requests that use this parameter instead
// continue to be valid.
ServerLaunchParameters *string
// This parameter is no longer used. Specify a server launch path using the
// RuntimeConfiguration parameter. Requests that use this parameter instead
// continue to be valid.
ServerLaunchPath *string
// A list of labels to assign to the new fleet resource. Tags are
// developer-defined key-value pairs. Tagging Amazon Web Services resources are
// useful for resource management, access management and cost allocation. For more
// information, see Tagging Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// in the Amazon Web Services General Reference.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateFleetOutput struct {
// The properties for the new fleet, including the current status. All fleets are
// placed in NEW status on creation.
FleetAttributes *types.FleetAttributes
// The fleet's locations and life-cycle status of each location. For new fleets,
// the status of all locations is set to NEW . During fleet creation, Amazon
// GameLift updates each location status as instances are deployed there and
// prepared for game hosting. This list includes an entry for the fleet's home
// Region. For fleets with no remote locations, only one entry, representing the
// home Region, is returned.
LocationStates []types.LocationState
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateFleetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateFleet{}, middleware.After)
if err != nil
|
{
return err
}
|
conditional_block
|
|
api_op_CreateFleet.go
|
(ctx context.Context, params *CreateFleetInput, optFns ...func(*Options)) (*CreateFleetOutput, error) {
if params == nil {
params = &CreateFleetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateFleet", params, optFns, c.addOperationCreateFleetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateFleetOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateFleetInput struct {
// A descriptive label that is associated with a fleet. Fleet names do not need to
// be unique.
//
// This member is required.
Name *string
// Amazon GameLift Anywhere configuration options.
AnywhereConfiguration *types.AnywhereConfiguration
// The unique identifier for a custom game server build to be deployed on fleet
// instances. You can use either the build ID or ARN. The build must be uploaded to
// Amazon GameLift and in READY status. This fleet property cannot be changed
// later.
BuildId *string
// Prompts Amazon GameLift to generate a TLS/SSL certificate for the fleet. Amazon
// GameLift uses the certificates to encrypt traffic between game clients and the
// game servers running on Amazon GameLift. By default, the
// CertificateConfiguration is DISABLED . You can't change this property after you
// create the fleet. Certificate Manager (ACM) certificates expire after 13 months.
// Certificate expiration can cause fleets to fail, preventing players from
// connecting to instances in the fleet. We recommend you replace fleets before 13
// months, consider using fleet aliases for a smooth transition. ACM isn't
// available in all Amazon Web Services regions. A fleet creation request with
// certificate generation enabled in an unsupported Region, fails with a 4xx error.
// For more information about the supported Regions, see Supported Regions (https://docs.aws.amazon.com/acm/latest/userguide/acm-regions.html)
// in the Certificate Manager User Guide.
CertificateConfiguration *types.CertificateConfiguration
// The type of compute resource used to host your game servers. You can use your
// own compute resources with Amazon GameLift Anywhere or use Amazon EC2 instances
// with managed Amazon GameLift. By default, this property is set to EC2 .
ComputeType types.ComputeType
// A description for the fleet.
Description *string
// The allowed IP address ranges and port settings that allow inbound traffic to
// access game sessions on this fleet. If the fleet is hosting a custom game build,
// this property must be set before players can connect to game sessions. For
// Realtime Servers fleets, Amazon GameLift automatically sets TCP and UDP ranges.
EC2InboundPermissions []types.IpPermission
// The Amazon GameLift-supported Amazon EC2 instance type to use for all fleet
// instances. Instance type determines the computing resources that will be used to
// host your game servers, including CPU, memory, storage, and networking capacity.
// See Amazon Elastic Compute Cloud Instance Types (http://aws.amazon.com/ec2/instance-types/)
// for detailed descriptions of Amazon EC2 instance types.
EC2InstanceType types.EC2InstanceType
// Indicates whether to use On-Demand or Spot instances for this fleet. By
// default, this property is set to ON_DEMAND . Learn more about when to use
// On-Demand versus Spot Instances (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot)
// . This property cannot be changed after the fleet is created.
FleetType types.FleetType
// A unique identifier for an IAM role that manages access to your Amazon Web
// Services services. With an instance role ARN set, any application that runs on
// an instance in this fleet can assume the role, including install scripts, server
// processes, and daemons (background processes). Create a role or look up a role's
// ARN by using the IAM dashboard (https://console.aws.amazon.com/iam/) in the
// Amazon Web Services Management Console. Learn more about using on-box
// credentials for your game servers at Access external resources from a game
// server (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-resources.html)
// . This property cannot be changed after the fleet is created.
InstanceRoleArn *string
// A set of remote locations to deploy additional instances to and manage as part
// of the fleet. This parameter can only be used when creating fleets in Amazon Web
// Services Regions that support multiple locations. You can add any Amazon
// GameLift-supported Amazon Web Services Region as a remote location, in the form
// of an Amazon Web Services Region code such as us-west-2 . To create a fleet with
// instances in the home Region only, don't use this parameter. To use this
// parameter, Amazon GameLift requires you to use your home location in the
// request.
Locations []types.LocationConfiguration
// This parameter is no longer used. To specify where Amazon GameLift should store
// log files once a server process shuts down, use the Amazon GameLift server API
// ProcessReady() and specify one or more directory paths in logParameters . For
// more information, see Initialize the server process (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-initialize)
// in the Amazon GameLift Developer Guide.
LogPaths []string
// The name of an Amazon Web Services CloudWatch metric group to add this fleet
// to. A metric group is used to aggregate the metrics for multiple fleets. You can
// specify an existing metric group name or set a new name to create a new metric
// group. A fleet can be included in only one metric group at a time.
MetricGroups []string
// The status of termination protection for active game sessions on the fleet. By
// default, this property is set to NoProtection . You can also set game session
// protection for an individual game session by calling UpdateGameSession .
// - NoProtection - Game sessions can be terminated during active gameplay as a
// result of a scale-down event.
// - FullProtection - Game sessions in ACTIVE status cannot be terminated during
// a scale-down event.
NewGameSessionProtectionPolicy types.ProtectionPolicy
// Used when peering your Amazon GameLift fleet with a VPC, the unique identifier
// for the Amazon Web Services account that owns the VPC. You can find your account
// ID in the Amazon Web Services Management Console under account settings.
PeerVpcAwsAccountId *string
// A unique identifier for a VPC with resources to be accessed by your Amazon
// GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
// VPC ID, use the VPC Dashboard (https://console.aws.amazon.com/vpc/) in the
// Amazon Web Services Management Console. Learn more about VPC peering in VPC
// Peering with Amazon GameLift Fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html)
// .
PeerVpcId *string
// A policy that limits the number of game sessions that an individual player can
// create on instances in this fleet within a specified span of time.
ResourceCreationLimitPolicy *types.ResourceCreationLimitPolicy
// Instructions for how to launch and maintain server processes on instances in
// the fleet. The runtime configuration defines one or more server process
// configurations, each identifying a build executable or Realtime script file and
// the number of processes of that type to run concurrently. The
// RuntimeConfiguration parameter is required unless the fleet is being configured
// using the older parameters ServerLaunchPath and ServerLaunchParameters , which
// are still supported for backward compatibility.
RuntimeConfiguration *types.RuntimeConfiguration
// The unique identifier for a Realtime configuration script to be deployed on
// fleet instances. You can use either the script ID or ARN. Scripts must be
// uploaded to Amazon GameLift prior to creating the fleet. This fleet property
// cannot be changed later.
ScriptId *string
// This parameter is no longer used. Specify server launch parameters using the
// RuntimeConfiguration parameter. Requests that use this parameter instead
// continue to be valid.
ServerLaunchParameters *string
// This parameter is no longer used. Specify a server launch path using the
// RuntimeConfiguration parameter. Requests that use this parameter instead
// continue to be valid.
ServerLaunchPath *string
// A list of labels to assign to the new fleet resource. Tags are
// developer-defined key-value pairs. Tagging Amazon Web Services resources are
// useful for resource management, access management and cost allocation. For more
// information, see Tagging Amazon Web Services Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
// in the Amazon Web Services General Reference.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateFleetOutput
|
CreateFleet
|
identifier_name
|
|
policy_handler.rs
|
]
pub trait PolicyHandler {
/// Called when a policy client makes a request on the policy API this handler controls.
async fn handle_policy_request(&mut self, request: PolicyRequest) -> Response;
/// Called when a setting request is intercepted for the setting this policy handler supervises.
///
/// If there are no policies or the request does not need to be modified, `None` should be
/// returned.
///
/// If this handler wants to consume the request and respond to the client directly, it should
/// return [`RequestTransform::Result`].
///
/// If this handler wants to modify the request, then let the setting handler handle it,
/// [`RequestTransform::Request`] should be returned, with the modified request.
///
/// [`RequestTransform::Result`]: enum.RequestTransform.html
/// [`RequestTransform::Request`]: enum.RequestTransform.html
async fn handle_setting_request(&mut self, request: Request) -> Option<RequestTransform>;
/// Called when a setting response is intercepted from the setting this policy handler
/// supervises.
///
/// If there are no policies or the response does not need to be modified, `None` should be
/// returned.
///
/// If this handler wants to modify the response and still let the original audience handle it,
/// [`Response`] should be returned, containing the modified response.
///
/// [`Response`]: ResponseTransform::Response
async fn handle_setting_response(
&mut self,
response: SettingResponse,
) -> Option<ResponseTransform>;
}
/// `RequestTransform` is returned by a [`PolicyHandler`] in response to a setting request that a
/// [`PolicyProxy`] intercepted. The presence of this value indicates that the policy handler has
/// decided to take action in order to apply policies.
///
/// [`PolicyHandler`]: trait.PolicyHandler.html
/// [`PolicyProxy`]: ../policy_proxy/struct.PolicyProxy.html
///
#[derive(Clone, Debug, PartialEq)]
pub enum RequestTransform {
/// A new, modified request that should be forwarded to the setting handler for processing.
Request(Request),
/// A result to return directly to the settings client.
Result(SettingHandlerResult),
}
/// `ResponseTransform` is returned by a [`PolicyHandler`] in response to a setting response that a
/// [`PolicyProxy`] intercepted. The presence of this value indicates that the policy handler has
/// decided to take action in order to apply policies.
///
/// [`PolicyHandler`]: trait.PolicyHandler.html
/// [`PolicyProxy`]: ../policy_proxy/struct.PolicyProxy.html
///
#[derive(Clone, Debug, PartialEq)]
pub enum ResponseTransform {
/// A new, modified response that should be forwarded.
Response(SettingResponse),
}
/// Trait used to create policy handlers.
#[async_trait]
pub trait Create: Sized {
async fn create(handler: ClientProxy) -> Result<Self, Error>;
}
/// Creates a [`PolicyHandler`] from the given [`Context`].
///
/// [`PolicyHandler`]: trait.PolicyHandler.html
/// [`Context`]: ../base/struct.Context.html
pub(crate) fn create_handler<C, T: StorageFactory<Storage = DeviceStorage> + 'static>(
context: Context<T>,
) -> BoxFuture<'static, GenerateHandlerResult>
where
C: Create + PolicyHandler + Send + Sync + 'static,
{
Box::pin(async move {
let _ = &context;
let proxy = ClientProxy::new(context.service_messenger);
C::create(proxy).await.map(|handler| Box::new(handler) as BoxedHandler)
})
}
/// `ClientProxy` provides common functionality, like messaging and persistence to policy handlers.
#[derive(Clone)]
pub struct ClientProxy {
service_messenger: service::message::Messenger,
}
impl ClientProxy {
/// Sends a setting request to the underlying setting proxy this policy handler controls.
pub(crate) fn send_setting_request(
&self,
setting_type: SettingType,
request: Request,
) -> service::message::Receptor {
self.service_messenger
.message(
HandlerPayload::Request(request).into(),
Audience::Address(service::Address::Handler(setting_type)),
)
.send()
}
/// Requests the setting handler to rebroadcast a settings changed event to its listeners.
pub(crate) fn request_rebroadcast(&self, setting_type: SettingType) {
// Ignore the receptor result.
let _ = self
.service_messenger
.message(
HandlerPayload::Request(Request::Rebroadcast).into(),
Audience::Address(service::Address::Handler(setting_type)),
)
.send();
}
}
impl ClientProxy {
pub(crate) fn new(service_messenger: service::message::Messenger) -> Self {
Self { service_messenger }
}
/// The type `T` is any type that has a [`PolicyType`] associated with it and that can be
/// converted into a [`PolicyInfo`]. This is usually a variant of the `PolicyInfo` enum.
pub(crate) async fn read_policy<T: HasPolicyType + TryFrom<PolicyInfo>>(
&self,
id: ftrace::Id,
) -> T {
let mut receptor = self
.service_messenger
.message(
storage::Payload::Request(storage::StorageRequest::Read(T::POLICY_TYPE.into(), id))
.into(),
Audience::Address(service::Address::Storage),
)
.send();
match receptor.next_of::<storage::Payload>().await {
Ok((payload, _)) => {
if let storage::Payload::Response(storage::StorageResponse::Read(
StorageInfo::PolicyInfo(policy_info),
)) = payload
{
let policy_type: PolicyType = (&policy_info).into();
if let Ok(info) = policy_info.try_into() {
return info;
}
panic!(
"Mismatching type during read. Expected {:?}, but got {:?}",
T::POLICY_TYPE,
policy_type
);
} else {
panic!("Incorrect response received from storage: {:?}", payload);
}
}
Err(err) => {
panic!("Error reading from storage: {:?}", err);
}
}
}
/// Write a policy info object to storage. The argument `write_through` will
/// block returning until the value has been completely written to
/// persistent store, rather than any temporary in-memory caching.
pub(crate) async fn write_policy(
&self,
policy_info: PolicyInfo,
id: ftrace::Id,
) -> Result<UpdateState, PolicyError> {
let policy_type = (&policy_info).into();
let mut receptor = self
.service_messenger
.message(
storage::Payload::Request(storage::StorageRequest::Write(policy_info.into(), id))
.into(),
Audience::Address(service::Address::Storage),
)
.send();
match receptor.next_of::<storage::Payload>().await {
Ok((payload, _)) => {
if let storage::Payload::Response(storage::StorageResponse::Write(result)) = payload
{
return result.map_err(|e| {
fx_log_err!("Failed to write policy: {:?}", e);
PolicyError::WriteFailure(policy_type)
});
} else {
fx_log_err!("Incorrect response received from storage: {:?}", payload);
}
}
Err(err) => {
fx_log_err!("Error writing to storage: {:?}", err);
}
}
Err(PolicyError::WriteFailure(policy_type))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::base::SettingType;
use crate::handler::base::{Payload as HandlerPayload, Request};
use crate::message::base::MessengerType;
use crate::message::MessageHubUtil;
use crate::policy::PolicyType;
use crate::service;
use crate::tests::message_utils::verify_payload;
#[fuchsia_async::run_until_stalled(test)]
async fn test_client_proxy_send_setting_request() {
let policy_type = PolicyType::Unknown;
let setting_request = Request::Get;
let target_setting_type = SettingType::Unknown;
let service_delegate = service::MessageHub::create_hub();
let (_, mut setting_proxy_receptor) = service_delegate
.create(MessengerType::Addressable(service::Address::Handler(
policy_type.setting_type(),
)))
.await
.expect("setting proxy messenger created");
let client_proxy = ClientProxy {
service_messenger: service_delegate
.create(MessengerType::Unbound)
.await
.expect("messenger should be created")
.0,
};
let _ = client_proxy.send_setting_request(target_setting_type, setting_request.clone());
verify_payload(
service::Payload::Setting(HandlerPayload::Request(setting_request)),
&mut setting_proxy_receptor,
None,
)
.await
}
#[fuchsia_async::run_until_stalled(test)]
async fn test_client_proxy_request_rebroadcast()
|
{
let setting_type = SettingType::Unknown;
let service_delegate = service::MessageHub::create_hub();
let (_, mut receptor) = service_delegate
.create(MessengerType::Addressable(service::Address::Handler(setting_type)))
.await
.expect("service receptor created");
let client_proxy = ClientProxy {
service_messenger: service_delegate
.create(MessengerType::Unbound)
.await
.expect("messenger should be created")
.0,
};
client_proxy.request_rebroadcast(setting_type);
|
identifier_body
|
|
policy_handler.rs
|
Factory};
use crate::message::base::Audience;
use crate::policy::response::{Error as PolicyError, Response};
use crate::policy::{
BoxedHandler, Context, GenerateHandlerResult, HasPolicyType, PolicyInfo, PolicyType,
Request as PolicyRequest,
};
use crate::service;
use crate::storage::{self, StorageInfo};
use anyhow::Error;
use async_trait::async_trait;
use fuchsia_syslog::fx_log_err;
use fuchsia_trace as ftrace;
use futures::future::BoxFuture;
use settings_storage::device_storage::DeviceStorage;
use settings_storage::UpdateState;
use std::convert::{TryFrom, TryInto};
/// PolicyHandlers are in charge of applying and persisting policies set by clients.
#[async_trait]
pub trait PolicyHandler {
/// Called when a policy client makes a request on the policy API this handler controls.
async fn handle_policy_request(&mut self, request: PolicyRequest) -> Response;
/// Called when a setting request is intercepted for the setting this policy handler supervises.
///
/// If there are no policies or the request does not need to be modified, `None` should be
/// returned.
///
/// If this handler wants to consume the request and respond to the client directly, it should
/// return [`RequestTransform::Result`].
///
/// If this handler wants to modify the request, then let the setting handler handle it,
/// [`RequestTransform::Request`] should be returned, with the modified request.
///
/// [`RequestTransform::Result`]: enum.RequestTransform.html
/// [`RequestTransform::Request`]: enum.RequestTransform.html
async fn handle_setting_request(&mut self, request: Request) -> Option<RequestTransform>;
/// Called when a setting response is intercepted from the setting this policy handler
/// supervises.
///
/// If there are no policies or the response does not need to be modified, `None` should be
/// returned.
///
/// If this handler wants to modify the response and still let the original audience handle it,
/// [`Response`] should be returned, containing the modified response.
///
/// [`Response`]: ResponseTransform::Response
async fn handle_setting_response(
&mut self,
response: SettingResponse,
) -> Option<ResponseTransform>;
}
/// `RequestTransform` is returned by a [`PolicyHandler`] in response to a setting request that a
/// [`PolicyProxy`] intercepted. The presence of this value indicates that the policy handler has
/// decided to take action in order to apply policies.
///
/// [`PolicyHandler`]: trait.PolicyHandler.html
/// [`PolicyProxy`]: ../policy_proxy/struct.PolicyProxy.html
///
#[derive(Clone, Debug, PartialEq)]
pub enum RequestTransform {
/// A new, modified request that should be forwarded to the setting handler for processing.
Request(Request),
/// A result to return directly to the settings client.
Result(SettingHandlerResult),
}
/// `ResponseTransform` is returned by a [`PolicyHandler`] in response to a setting response that a
/// [`PolicyProxy`] intercepted. The presence of this value indicates that the policy handler has
/// decided to take action in order to apply policies.
///
/// [`PolicyHandler`]: trait.PolicyHandler.html
/// [`PolicyProxy`]: ../policy_proxy/struct.PolicyProxy.html
///
#[derive(Clone, Debug, PartialEq)]
pub enum ResponseTransform {
/// A new, modified response that should be forwarded.
Response(SettingResponse),
}
/// Trait used to create policy handlers.
#[async_trait]
pub trait Create: Sized {
async fn create(handler: ClientProxy) -> Result<Self, Error>;
}
/// Creates a [`PolicyHandler`] from the given [`Context`].
///
/// [`PolicyHandler`]: trait.PolicyHandler.html
/// [`Context`]: ../base/struct.Context.html
pub(crate) fn create_handler<C, T: StorageFactory<Storage = DeviceStorage> + 'static>(
context: Context<T>,
) -> BoxFuture<'static, GenerateHandlerResult>
where
C: Create + PolicyHandler + Send + Sync + 'static,
{
Box::pin(async move {
let _ = &context;
let proxy = ClientProxy::new(context.service_messenger);
C::create(proxy).await.map(|handler| Box::new(handler) as BoxedHandler)
})
}
/// `ClientProxy` provides common functionality, like messaging and persistence to policy handlers.
#[derive(Clone)]
pub struct ClientProxy {
service_messenger: service::message::Messenger,
}
impl ClientProxy {
/// Sends a setting request to the underlying setting proxy this policy handler controls.
pub(crate) fn send_setting_request(
&self,
setting_type: SettingType,
request: Request,
) -> service::message::Receptor {
self.service_messenger
.message(
HandlerPayload::Request(request).into(),
Audience::Address(service::Address::Handler(setting_type)),
)
.send()
}
/// Requests the setting handler to rebroadcast a settings changed event to its listeners.
pub(crate) fn request_rebroadcast(&self, setting_type: SettingType) {
// Ignore the receptor result.
let _ = self
.service_messenger
.message(
HandlerPayload::Request(Request::Rebroadcast).into(),
Audience::Address(service::Address::Handler(setting_type)),
)
.send();
}
}
impl ClientProxy {
pub(crate) fn new(service_messenger: service::message::Messenger) -> Self {
Self { service_messenger }
}
/// The type `T` is any type that has a [`PolicyType`] associated with it and that can be
/// converted into a [`PolicyInfo`]. This is usually a variant of the `PolicyInfo` enum.
pub(crate) async fn read_policy<T: HasPolicyType + TryFrom<PolicyInfo>>(
&self,
id: ftrace::Id,
) -> T {
let mut receptor = self
.service_messenger
.message(
storage::Payload::Request(storage::StorageRequest::Read(T::POLICY_TYPE.into(), id))
.into(),
Audience::Address(service::Address::Storage),
)
.send();
match receptor.next_of::<storage::Payload>().await {
Ok((payload, _)) => {
if let storage::Payload::Response(storage::StorageResponse::Read(
StorageInfo::PolicyInfo(policy_info),
)) = payload
{
let policy_type: PolicyType = (&policy_info).into();
if let Ok(info) = policy_info.try_into() {
return info;
}
panic!(
"Mismatching type during read. Expected {:?}, but got {:?}",
T::POLICY_TYPE,
policy_type
);
} else {
panic!("Incorrect response received from storage: {:?}", payload);
}
}
Err(err) => {
panic!("Error reading from storage: {:?}", err);
}
}
}
/// Write a policy info object to storage. The argument `write_through` will
/// block returning until the value has been completely written to
/// persistent store, rather than any temporary in-memory caching.
pub(crate) async fn
|
(
&self,
policy_info: PolicyInfo,
id: ftrace::Id,
) -> Result<UpdateState, PolicyError> {
let policy_type = (&policy_info).into();
let mut receptor = self
.service_messenger
.message(
storage::Payload::Request(storage::StorageRequest::Write(policy_info.into(), id))
.into(),
Audience::Address(service::Address::Storage),
)
.send();
match receptor.next_of::<storage::Payload>().await {
Ok((payload, _)) => {
if let storage::Payload::Response(storage::StorageResponse::Write(result)) = payload
{
return result.map_err(|e| {
fx_log_err!("Failed to write policy: {:?}", e);
PolicyError::WriteFailure(policy_type)
});
} else {
fx_log_err!("Incorrect response received from storage: {:?}", payload);
}
}
Err(err) => {
fx_log_err!("Error writing to storage: {:?}", err);
}
}
Err(PolicyError::WriteFailure(policy_type))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::base::SettingType;
use crate::handler::base::{Payload as HandlerPayload, Request};
use crate::message::base::MessengerType;
use crate::message::MessageHubUtil;
use crate::policy::PolicyType;
use crate::service;
use crate::tests::message_utils::verify_payload;
#[fuchsia_async::run_until_stalled(test)]
async fn test_client_proxy_send_setting_request() {
let policy_type = PolicyType::Unknown;
let setting_request = Request::Get;
let target_setting_type = SettingType::Unknown;
let service_delegate = service::MessageHub::create_hub();
let (_, mut setting_proxy_receptor) = service_delegate
.create(MessengerType::Addressable(service::Address::Handler(
policy_type.setting_type(),
)))
.await
.expect("setting proxy messenger created");
let client_proxy = ClientProxy {
service_messenger: service_delegate
.create(MessengerType::Unbound)
.await
.expect("messenger should be created")
.0,
};
let _ = client_proxy.send_setting_request(target_setting_type, setting_request.clone());
verify_payload(
service::Payload::Setting(HandlerPayload::Request(setting_request)),
|
write_policy
|
identifier_name
|
policy_handler.rs
|
Factory};
use crate::message::base::Audience;
use crate::policy::response::{Error as PolicyError, Response};
use crate::policy::{
BoxedHandler, Context, GenerateHandlerResult, HasPolicyType, PolicyInfo, PolicyType,
Request as PolicyRequest,
};
use crate::service;
use crate::storage::{self, StorageInfo};
use anyhow::Error;
use async_trait::async_trait;
use fuchsia_syslog::fx_log_err;
use fuchsia_trace as ftrace;
use futures::future::BoxFuture;
use settings_storage::device_storage::DeviceStorage;
use settings_storage::UpdateState;
use std::convert::{TryFrom, TryInto};
/// PolicyHandlers are in charge of applying and persisting policies set by clients.
#[async_trait]
pub trait PolicyHandler {
/// Called when a policy client makes a request on the policy API this handler controls.
async fn handle_policy_request(&mut self, request: PolicyRequest) -> Response;
/// Called when a setting request is intercepted for the setting this policy handler supervises.
///
/// If there are no policies or the request does not need to be modified, `None` should be
/// returned.
///
/// If this handler wants to consume the request and respond to the client directly, it should
/// return [`RequestTransform::Result`].
///
/// If this handler wants to modify the request, then let the setting handler handle it,
/// [`RequestTransform::Request`] should be returned, with the modified request.
///
/// [`RequestTransform::Result`]: enum.RequestTransform.html
/// [`RequestTransform::Request`]: enum.RequestTransform.html
async fn handle_setting_request(&mut self, request: Request) -> Option<RequestTransform>;
/// Called when a setting response is intercepted from the setting this policy handler
/// supervises.
///
/// If there are no policies or the response does not need to be modified, `None` should be
/// returned.
///
/// If this handler wants to modify the response and still let the original audience handle it,
/// [`Response`] should be returned, containing the modified response.
///
/// [`Response`]: ResponseTransform::Response
async fn handle_setting_response(
&mut self,
response: SettingResponse,
) -> Option<ResponseTransform>;
}
/// `RequestTransform` is returned by a [`PolicyHandler`] in response to a setting request that a
/// [`PolicyProxy`] intercepted. The presence of this value indicates that the policy handler has
/// decided to take action in order to apply policies.
///
/// [`PolicyHandler`]: trait.PolicyHandler.html
/// [`PolicyProxy`]: ../policy_proxy/struct.PolicyProxy.html
///
#[derive(Clone, Debug, PartialEq)]
pub enum RequestTransform {
/// A new, modified request that should be forwarded to the setting handler for processing.
Request(Request),
/// A result to return directly to the settings client.
Result(SettingHandlerResult),
}
/// `ResponseTransform` is returned by a [`PolicyHandler`] in response to a setting response that a
/// [`PolicyProxy`] intercepted. The presence of this value indicates that the policy handler has
/// decided to take action in order to apply policies.
///
/// [`PolicyHandler`]: trait.PolicyHandler.html
/// [`PolicyProxy`]: ../policy_proxy/struct.PolicyProxy.html
///
#[derive(Clone, Debug, PartialEq)]
pub enum ResponseTransform {
/// A new, modified response that should be forwarded.
Response(SettingResponse),
}
/// Trait used to create policy handlers.
#[async_trait]
pub trait Create: Sized {
async fn create(handler: ClientProxy) -> Result<Self, Error>;
}
/// Creates a [`PolicyHandler`] from the given [`Context`].
///
/// [`PolicyHandler`]: trait.PolicyHandler.html
/// [`Context`]: ../base/struct.Context.html
pub(crate) fn create_handler<C, T: StorageFactory<Storage = DeviceStorage> + 'static>(
context: Context<T>,
) -> BoxFuture<'static, GenerateHandlerResult>
where
C: Create + PolicyHandler + Send + Sync + 'static,
{
Box::pin(async move {
let _ = &context;
let proxy = ClientProxy::new(context.service_messenger);
C::create(proxy).await.map(|handler| Box::new(handler) as BoxedHandler)
})
}
/// `ClientProxy` provides common functionality, like messaging and persistence to policy handlers.
#[derive(Clone)]
pub struct ClientProxy {
service_messenger: service::message::Messenger,
}
|
impl ClientProxy {
/// Sends a setting request to the underlying setting proxy this policy handler controls.
pub(crate) fn send_setting_request(
&self,
setting_type: SettingType,
request: Request,
) -> service::message::Receptor {
self.service_messenger
.message(
HandlerPayload::Request(request).into(),
Audience::Address(service::Address::Handler(setting_type)),
)
.send()
}
/// Requests the setting handler to rebroadcast a settings changed event to its listeners.
pub(crate) fn request_rebroadcast(&self, setting_type: SettingType) {
// Ignore the receptor result.
let _ = self
.service_messenger
.message(
HandlerPayload::Request(Request::Rebroadcast).into(),
Audience::Address(service::Address::Handler(setting_type)),
)
.send();
}
}
impl ClientProxy {
pub(crate) fn new(service_messenger: service::message::Messenger) -> Self {
Self { service_messenger }
}
/// The type `T` is any type that has a [`PolicyType`] associated with it and that can be
/// converted into a [`PolicyInfo`]. This is usually a variant of the `PolicyInfo` enum.
pub(crate) async fn read_policy<T: HasPolicyType + TryFrom<PolicyInfo>>(
&self,
id: ftrace::Id,
) -> T {
let mut receptor = self
.service_messenger
.message(
storage::Payload::Request(storage::StorageRequest::Read(T::POLICY_TYPE.into(), id))
.into(),
Audience::Address(service::Address::Storage),
)
.send();
match receptor.next_of::<storage::Payload>().await {
Ok((payload, _)) => {
if let storage::Payload::Response(storage::StorageResponse::Read(
StorageInfo::PolicyInfo(policy_info),
)) = payload
{
let policy_type: PolicyType = (&policy_info).into();
if let Ok(info) = policy_info.try_into() {
return info;
}
panic!(
"Mismatching type during read. Expected {:?}, but got {:?}",
T::POLICY_TYPE,
policy_type
);
} else {
panic!("Incorrect response received from storage: {:?}", payload);
}
}
Err(err) => {
panic!("Error reading from storage: {:?}", err);
}
}
}
/// Write a policy info object to storage. The argument `write_through` will
/// block returning until the value has been completely written to
/// persistent store, rather than any temporary in-memory caching.
pub(crate) async fn write_policy(
&self,
policy_info: PolicyInfo,
id: ftrace::Id,
) -> Result<UpdateState, PolicyError> {
let policy_type = (&policy_info).into();
let mut receptor = self
.service_messenger
.message(
storage::Payload::Request(storage::StorageRequest::Write(policy_info.into(), id))
.into(),
Audience::Address(service::Address::Storage),
)
.send();
match receptor.next_of::<storage::Payload>().await {
Ok((payload, _)) => {
if let storage::Payload::Response(storage::StorageResponse::Write(result)) = payload
{
return result.map_err(|e| {
fx_log_err!("Failed to write policy: {:?}", e);
PolicyError::WriteFailure(policy_type)
});
} else {
fx_log_err!("Incorrect response received from storage: {:?}", payload);
}
}
Err(err) => {
fx_log_err!("Error writing to storage: {:?}", err);
}
}
Err(PolicyError::WriteFailure(policy_type))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::base::SettingType;
use crate::handler::base::{Payload as HandlerPayload, Request};
use crate::message::base::MessengerType;
use crate::message::MessageHubUtil;
use crate::policy::PolicyType;
use crate::service;
use crate::tests::message_utils::verify_payload;
#[fuchsia_async::run_until_stalled(test)]
async fn test_client_proxy_send_setting_request() {
let policy_type = PolicyType::Unknown;
let setting_request = Request::Get;
let target_setting_type = SettingType::Unknown;
let service_delegate = service::MessageHub::create_hub();
let (_, mut setting_proxy_receptor) = service_delegate
.create(MessengerType::Addressable(service::Address::Handler(
policy_type.setting_type(),
)))
.await
.expect("setting proxy messenger created");
let client_proxy = ClientProxy {
service_messenger: service_delegate
.create(MessengerType::Unbound)
.await
.expect("messenger should be created")
.0,
};
let _ = client_proxy.send_setting_request(target_setting_type, setting_request.clone());
verify_payload(
service::Payload::Setting(HandlerPayload::Request(setting_request)),
|
random_line_split
|
|
projectsvmglove.py
|
elif w == 'goood':
return 'very good'
elif w == 'tera':
return 'teraa'
elif w == 'cnfsn':
return 'confusion'
elif w == 'ka':
return 'kaa'
elif w == 'rkhi':
return 'rakhi'
elif w == 'thts':
return 'thats'
elif w == 'cald':
return 'called'
elif w == 'tabhe':
return 'tabhi'
elif w == 'pta':
return 'pata'
elif w == 'b':
return 'bhi'
elif w == 'nai':
return 'nahi'
elif w == 'f':
return 'of'
elif w == 'd':
return 'the'
else:
return w
'''
Translate word .
'''
def translate(word):
return translator.translate(word,src='hi' , dest='en').text
'''
Self defined contractions
'''
def load_dict_contractions():
return {
"ain't":"is not",
"amn't":"am not",
"aren't":"are not",
"can't":"cannot",
"'cause":"because",
"couldn't":"could not",
"couldn't've":"could not have",
"could've":"could have",
"daren't":"dare not",
"daresn't":"dare not",
"dasn't":"dare not",
"didn't":"did not",
"doesn't":"does not",
"don't":"do not",
"e'er":"ever",
"em":"them",
"everyone's":"everyone is",
"finna":"fixing to",
"gimme":"give me",
"gonna":"going to",
"gon't":"go not",
"gotta":"got to",
"hadn't":"had not",
"hasn't":"has not",
"haven't":"have not",
"he'd":"he would",
"he'll":"he will",
"he's":"he is",
"he've":"he have",
"how'd":"how would",
"how'll":"how will",
"how're":"how are",
"how's":"how is",
"I'd":"I would",
"I'll":"I will",
"i'll":"I will",
"I'm":"I am",
"I'm'a":"I am about to",
"I'm'o":"I am going to",
"isn't":"is not",
"it'd":"it would",
"it'll":"it will",
"it's":"it is",
"I've":"I have",
"kinda":"kind of",
"let's":"let us",
"mayn't":"may not",
"may've":"may have",
"mightn't":"might not",
"might've":"might have",
"mustn't":"must not",
"mustn't've":"must not have",
"must've":"must have",
"needn't":"need not",
"ne'er":"never",
"o'":"of",
"o'er":"over",
"ol'":"old",
"oughtn't":"ought not",
"shalln't":"shall not",
"shan't":"shall not",
"she'd":"she would",
"she'll":"she will",
"she's":"she is",
"shouldn't":"should not",
"shouldn't've":"should not have",
"should've":"should have",
"somebody's":"somebody is",
"someone's":"someone is",
"something's":"something is",
"that'd":"that would",
"that'll":"that will",
"that're":"that are",
"that's":"that is",
"there'd":"there would",
"there'll":"there will",
"there're":"there are",
"there's":"there is",
"these're":"these are",
"they'd":"they would",
"they'll":"they will",
"they're":"they are",
"they've":"they have",
"this's":"this is",
"those're":"those are",
"'tis":"it is",
"'twas":"it was",
"wanna":"want to",
"wasn't":"was not",
"we'd":"we would",
"we'd've":"we would have",
"we'll":"we will",
"we're":"we are",
"weren't":"were not",
"we've":"we have",
"what'd":"what did",
"what'll":"what will",
"what're":"what are",
"what's":"what is",
"what've":"what have",
"when's":"when is",
"where'd":"where did",
"where're":"where are",
"where's":"where is",
"where've":"where have",
"which's":"which is",
"who'd":"who would",
"who'd've":"who would have",
"who'll":"who will",
"who're":"who are",
"who's":"who is",
"who've":"who have",
"why'd":"why did",
"why're":"why are",
"why's":"why is",
"won't":"will not",
"wouldn't":"would not",
"would've":"would have",
"y'all":"you all",
"you'd":"you would",
"you'll":"you will",
"you're":"you are",
"you've":"you have",
"Whatcha":"What are you",
"whatcha":"What are you",
"luv":"love",
"sux":"sucks"
}
'''
Handling short forms and contractions in the sentences
'''
long_form_dict = load_dict_contractions()
def expand_sent(sentence):
final_sent =""
res = " ".join(long_form_dict.get(ele, ele) for ele in sentence.split())
for word in res.split():
final_sent += (handle_short_forms(word))+ " "
return final_sent
data.shape
l=[]
for sent in data.sentence_eng:
l.append(expand_sent(sent))
print(l[2:5])
data['sentence_eng']=l
'''
Emoticon processing
'''
emoji_list = pd.read_csv('emoji.csv',sep=",")
def find_emoji(sentence):
positive = 0
negative = 0
neutral = 0
sentiment =[]
for word in sentence.split():
if not emoji_list[emoji_list['Emoji']==word].empty:
positive += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Positive']
negative += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Negative']
neutral += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Neutral']
return positive,negative,neutral
'''
Slang word processing
'''
slang_list = pd.read_csv('Hinglish_Profanity_List.csv',sep=",",header=None)
slang_list.columns=['hindi_word','meaning','rating']
def find_slang(sentence):
slang_exists = False
total_rating = 0
for word in sentence.split():
if not slang_list[slang_list['hindi_word']==word].empty:
try:
total_rating += slang_list.iloc[slang_list.index[slang_list['hindi_word'] == word].tolist()[0]]['rating']
except:
total_rating +=0
slang_exists = True
try:
total_rating = int(total_rating)
except:
total_rating = 0
return slang_exists,total_rating
data['slang_exists']= data['sentence_mixed'].apply(find_slang)
data[['slang_existance', 'slang_rating']] = pd.DataFrame(data['slang_exists'].tolist(), index=data.index)
data =data.drop(columns=['slang_exists'])
data['emoji_sentiment'] = data['sentence_mixed'].apply(find_emoji)
data[['positive_emoji', 'negative_emoji','neutral_emoji']] = pd.DataFrame(data['emoji_sentiment'].tolist(), index=data.index)
data =data.drop(columns=['emoji_sentiment'])
'''
Calculating the sentiment polarity score
'''
sid = SentimentIntensityAnalyzer()
neg_score=[]
pos_score=[]
neu_score=[]
for sent in data.sentence_eng:
ss = sid.polarity_scores(sent)
neg_score.append(ss['neg'])
pos_score.append(ss['pos'])
neu_score.append(ss['neu'])
data['neg_score']= neg_score
data['pos_score']= pos_score
data['neu_score']= neu_score
data
|
if w == 'h':
return 'hai'
elif w == 'n':
return 'na'
elif w == 'da':
return 'the'
elif w == 'wid':
return 'with'
elif w == 'pr':
return 'par'
elif w == 'mattt':
return 'mat'
elif w == 'vo':
return 'woh'
elif w == 'ki':
return 'kee'
elif w == 'ap':
return 'aap'
elif w == 'bs':
return 'bas'
|
identifier_body
|
|
projectsvmglove.py
|
":"she will",
"she's":"she is",
"shouldn't":"should not",
"shouldn't've":"should not have",
"should've":"should have",
"somebody's":"somebody is",
"someone's":"someone is",
"something's":"something is",
"that'd":"that would",
"that'll":"that will",
"that're":"that are",
"that's":"that is",
"there'd":"there would",
"there'll":"there will",
"there're":"there are",
"there's":"there is",
"these're":"these are",
"they'd":"they would",
"they'll":"they will",
"they're":"they are",
"they've":"they have",
"this's":"this is",
"those're":"those are",
"'tis":"it is",
"'twas":"it was",
"wanna":"want to",
"wasn't":"was not",
"we'd":"we would",
"we'd've":"we would have",
"we'll":"we will",
"we're":"we are",
"weren't":"were not",
"we've":"we have",
"what'd":"what did",
"what'll":"what will",
"what're":"what are",
"what's":"what is",
"what've":"what have",
"when's":"when is",
"where'd":"where did",
"where're":"where are",
"where's":"where is",
"where've":"where have",
"which's":"which is",
"who'd":"who would",
"who'd've":"who would have",
"who'll":"who will",
"who're":"who are",
"who's":"who is",
"who've":"who have",
"why'd":"why did",
"why're":"why are",
"why's":"why is",
"won't":"will not",
"wouldn't":"would not",
"would've":"would have",
"y'all":"you all",
"you'd":"you would",
"you'll":"you will",
"you're":"you are",
"you've":"you have",
"Whatcha":"What are you",
"whatcha":"What are you",
"luv":"love",
"sux":"sucks"
}
'''
Handling short forms and contractions in the sentences
'''
long_form_dict = load_dict_contractions()
def expand_sent(sentence):
final_sent =""
res = " ".join(long_form_dict.get(ele, ele) for ele in sentence.split())
for word in res.split():
final_sent += (handle_short_forms(word))+ " "
return final_sent
data.shape
l=[]
for sent in data.sentence_eng:
l.append(expand_sent(sent))
print(l[2:5])
data['sentence_eng']=l
'''
Emoticon processing
'''
emoji_list = pd.read_csv('emoji.csv',sep=",")
def find_emoji(sentence):
positive = 0
negative = 0
neutral = 0
sentiment =[]
for word in sentence.split():
if not emoji_list[emoji_list['Emoji']==word].empty:
positive += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Positive']
negative += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Negative']
neutral += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Neutral']
return positive,negative,neutral
'''
Slang word processing
'''
slang_list = pd.read_csv('Hinglish_Profanity_List.csv',sep=",",header=None)
slang_list.columns=['hindi_word','meaning','rating']
def find_slang(sentence):
slang_exists = False
total_rating = 0
for word in sentence.split():
if not slang_list[slang_list['hindi_word']==word].empty:
try:
total_rating += slang_list.iloc[slang_list.index[slang_list['hindi_word'] == word].tolist()[0]]['rating']
except:
total_rating +=0
slang_exists = True
try:
total_rating = int(total_rating)
except:
total_rating = 0
return slang_exists,total_rating
data['slang_exists']= data['sentence_mixed'].apply(find_slang)
data[['slang_existance', 'slang_rating']] = pd.DataFrame(data['slang_exists'].tolist(), index=data.index)
data =data.drop(columns=['slang_exists'])
data['emoji_sentiment'] = data['sentence_mixed'].apply(find_emoji)
data[['positive_emoji', 'negative_emoji','neutral_emoji']] = pd.DataFrame(data['emoji_sentiment'].tolist(), index=data.index)
data =data.drop(columns=['emoji_sentiment'])
'''
Calculating the sentiment polarity score
'''
sid = SentimentIntensityAnalyzer()
neg_score=[]
pos_score=[]
neu_score=[]
for sent in data.sentence_eng:
ss = sid.polarity_scores(sent)
neg_score.append(ss['neg'])
pos_score.append(ss['pos'])
neu_score.append(ss['neu'])
data['neg_score']= neg_score
data['pos_score']= pos_score
data['neu_score']= neu_score
data.tail(10)
# removing unwanted patterns from the data
import re
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords
from nltk.stem.porter import PorterStemmer
#Splitting the data
train = data[:5000]
test = data[5000:]
'''
fetching the sentence/comments from the test dataset and cleaning it
'''
train_corpus = []
for i in range(0, 5000):
review = re.sub('[^a-zA-Z]', ' ', train['sentence_eng'][i])
review = review.lower()
review = review.split()
ps = PorterStemmer()
# stemming
review = [ps.stem(word) for word in review if not word in set(stopwords.words('english'))]
# joining them back with space
review = ' '.join(review)
train_corpus.append(review)
'''
fetching the sentence/comments from the test dataset and cleaning it
'''
test_corpus = []
for i in range(5000, 6137):
review = re.sub('[^a-zA-Z]', ' ', test['sentence_eng'][i])
review = review.lower()
review = review.split()
ps = PorterStemmer()
# stemming
review = [ps.stem(word) for word in review if not word in set(stopwords.words('english'))]
# joining them back with space
review = ' '.join(review)
test_corpus.append(review)
#Conversion of snetiment into numerical sentiment
train =train.replace("positive",1)
train =train.replace("negative",2)
train = train.replace("neutral",0)
train.head()
y = train.iloc[:, 2]
print(y)
from nltk.tokenize import WordPunctTokenizer
tokenizer = WordPunctTokenizer()
data_tok = [tokenizer.tokenize(d.lower()) for d in train_corpus]
import gensim.downloader as api
model = api.load('glove-twitter-50')
import numpy as np
def get_phrase_embedding(phrase):
"""
Convert phrase to a vector by aggregating it's word embeddings. Just take an
average of vectors for all tokens in the phrase with some weights.
"""
vector = np.zeros([model.vector_size], dtype='float32')
# 1. lowercase phrase
phrase = phrase.lower()
# 2. tokenize phrase
phrase_tokens = tokenizer.tokenize(phrase)
# 3. average word vectors for all words in tokenized phrase, skip words that are not in model's vocabulary
divisor = 0
for word in phrase_tokens:
if word in model.vocab:
divisor += 1
vector = vector + model.get_vector(word)
if divisor != 0: vector /= divisor
return vector
'''
Embeddings for Training Corpus
'''
vector_matrix_x_train = list(map(get_phrase_embedding, train_corpus))
'''
Embeddings for Training Corpus
'''
vector_matrix_x_test = list(map(get_phrase_embedding, test_corpus))
numerical_features_t = train[['neg_score','pos_score', 'neu_score', 'positive_emoji', 'negative_emoji', 'neutral_emoji', 'slang_rating']]
print(numerical_features_t.values.tolist())
'''
Stacking numerical features along with textual features
'''
combinedFeatures = np.hstack([numerical_features_t, np.array(vector_matrix_x_train)])
numerical_features_test = test[['neg_score','pos_score', 'neu_score', 'positive_emoji', 'negative_emoji', 'neutral_emoji', 'slang_rating']]
print(numerical_features_test.values.tolist())
combinedFeatures_test = np.hstack([numerical_features_test, np.array(vector_matrix_x_test)])
from sklearn.model_selection import train_test_split
'''
Train test validation split
'''
x_train, x_valid, y_train, y_valid = train_test_split(combinedFeatures, y, test_size = 0.25, random_state = 42)
print(x_train.shape)
|
print(x_valid.shape)
print(y_train.shape)
print(y_valid.shape)
print(combinedFeatures_test.shape)
|
random_line_split
|
|
projectsvmglove.py
|
elif w == 'goood':
return 'very good'
elif w == 'tera':
return 'teraa'
elif w == 'cnfsn':
return 'confusion'
elif w == 'ka':
return 'kaa'
elif w == 'rkhi':
return 'rakhi'
elif w == 'thts':
return 'thats'
elif w == 'cald':
return 'called'
elif w == 'tabhe':
return 'tabhi'
elif w == 'pta':
return 'pata'
elif w == 'b':
return 'bhi'
elif w == 'nai':
return 'nahi'
elif w == 'f':
return 'of'
elif w == 'd':
return 'the'
else:
return w
'''
Translate word .
'''
def translate(word):
return translator.translate(word,src='hi' , dest='en').text
'''
Self defined contractions
'''
def load_dict_contractions():
return {
"ain't":"is not",
"amn't":"am not",
"aren't":"are not",
"can't":"cannot",
"'cause":"because",
"couldn't":"could not",
"couldn't've":"could not have",
"could've":"could have",
"daren't":"dare not",
"daresn't":"dare not",
"dasn't":"dare not",
"didn't":"did not",
"doesn't":"does not",
"don't":"do not",
"e'er":"ever",
"em":"them",
"everyone's":"everyone is",
"finna":"fixing to",
"gimme":"give me",
"gonna":"going to",
"gon't":"go not",
"gotta":"got to",
"hadn't":"had not",
"hasn't":"has not",
"haven't":"have not",
"he'd":"he would",
"he'll":"he will",
"he's":"he is",
"he've":"he have",
"how'd":"how would",
"how'll":"how will",
"how're":"how are",
"how's":"how is",
"I'd":"I would",
"I'll":"I will",
"i'll":"I will",
"I'm":"I am",
"I'm'a":"I am about to",
"I'm'o":"I am going to",
"isn't":"is not",
"it'd":"it would",
"it'll":"it will",
"it's":"it is",
"I've":"I have",
"kinda":"kind of",
"let's":"let us",
"mayn't":"may not",
"may've":"may have",
"mightn't":"might not",
"might've":"might have",
"mustn't":"must not",
"mustn't've":"must not have",
"must've":"must have",
"needn't":"need not",
"ne'er":"never",
"o'":"of",
"o'er":"over",
"ol'":"old",
"oughtn't":"ought not",
"shalln't":"shall not",
"shan't":"shall not",
"she'd":"she would",
"she'll":"she will",
"she's":"she is",
"shouldn't":"should not",
"shouldn't've":"should not have",
"should've":"should have",
"somebody's":"somebody is",
"someone's":"someone is",
"something's":"something is",
"that'd":"that would",
"that'll":"that will",
"that're":"that are",
"that's":"that is",
"there'd":"there would",
"there'll":"there will",
"there're":"there are",
"there's":"there is",
"these're":"these are",
"they'd":"they would",
"they'll":"they will",
"they're":"they are",
"they've":"they have",
"this's":"this is",
"those're":"those are",
"'tis":"it is",
"'twas":"it was",
"wanna":"want to",
"wasn't":"was not",
"we'd":"we would",
"we'd've":"we would have",
"we'll":"we will",
"we're":"we are",
"weren't":"were not",
"we've":"we have",
"what'd":"what did",
"what'll":"what will",
"what're":"what are",
"what's":"what is",
"what've":"what have",
"when's":"when is",
"where'd":"where did",
"where're":"where are",
"where's":"where is",
"where've":"where have",
"which's":"which is",
"who'd":"who would",
"who'd've":"who would have",
"who'll":"who will",
"who're":"who are",
"who's":"who is",
"who've":"who have",
"why'd":"why did",
"why're":"why are",
"why's":"why is",
"won't":"will not",
"wouldn't":"would not",
"would've":"would have",
"y'all":"you all",
"you'd":"you would",
"you'll":"you will",
"you're":"you are",
"you've":"you have",
"Whatcha":"What are you",
"whatcha":"What are you",
"luv":"love",
"sux":"sucks"
}
'''
Handling short forms and contractions in the sentences
'''
long_form_dict = load_dict_contractions()
def expand_sent(sentence):
final_sent =""
res = " ".join(long_form_dict.get(ele, ele) for ele in sentence.split())
for word in res.split():
final_sent += (handle_short_forms(word))+ " "
return final_sent
data.shape
l=[]
for sent in data.sentence_eng:
l.append(expand_sent(sent))
print(l[2:5])
data['sentence_eng']=l
'''
Emoticon processing
'''
emoji_list = pd.read_csv('emoji.csv',sep=",")
def find_emoji(sentence):
positive = 0
negative = 0
neutral = 0
sentiment =[]
for word in sentence.split():
if not emoji_list[emoji_list['Emoji']==word].empty:
positive += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Positive']
negative += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Negative']
neutral += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Neutral']
return positive,negative,neutral
'''
Slang word processing
'''
slang_list = pd.read_csv('Hinglish_Profanity_List.csv',sep=",",header=None)
slang_list.columns=['hindi_word','meaning','rating']
def find_slang(sentence):
slang_exists = False
total_rating = 0
for word in sentence.split():
if not slang_list[slang_list['hindi_word']==word].empty:
try:
total_rating += slang_list.iloc[slang_list.index[slang_list['hindi_word'] == word].tolist()[0]]['rating']
except:
total_rating +=0
slang_exists = True
try:
total_rating = int(total_rating)
except:
total_rating = 0
return slang_exists,total_rating
data['slang_exists']= data['sentence_mixed'].apply(find_slang)
data[['slang_existance', 'slang_rating']] = pd.DataFrame(data['slang_exists'].tolist(), index=data.index)
data =data.drop(columns=['slang_exists'])
data['emoji_sentiment'] = data['sentence_mixed'].apply(find_emoji)
data[['positive_emoji', 'negative_emoji','neutral_emoji']] = pd.DataFrame(data['emoji_sentiment'].tolist(), index=data.index)
data =data.drop(columns=['emoji_sentiment'])
'''
Calculating the sentiment polarity score
'''
sid = SentimentIntensityAnalyzer()
neg_score=[]
pos_score=[]
neu_score=[]
for sent in data.sentence_eng:
ss = sid.polarity_scores(sent)
neg_score.append(ss['neg'])
pos_score.append(ss['pos'])
neu_score.append(ss['neu'])
data['neg_score']= neg_score
data['pos_score']= pos_score
data['neu_score']= neu_score
data.tail(10)
# removing unwanted patterns from the data
import re
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords
from nltk.stem.porter import PorterStemmer
#Splitting the data
train = data[:5000]
test = data[5000:]
'''
fetching the sentence/comments from the test dataset and cleaning it
'''
train_corpus = []
for i in range(0, 5000):
review = re.sub('[^a-zA-Z]', ' ', train['sentence_eng'][i
|
return 'bas'
|
conditional_block
|
|
projectsvmglove.py
|
ata'
elif w == 'b':
return 'bhi'
elif w == 'nai':
return 'nahi'
elif w == 'f':
return 'of'
elif w == 'd':
return 'the'
else:
return w
'''
Translate word .
'''
def translate(word):
return translator.translate(word,src='hi' , dest='en').text
'''
Self defined contractions
'''
def load_dict_contractions():
return {
"ain't":"is not",
"amn't":"am not",
"aren't":"are not",
"can't":"cannot",
"'cause":"because",
"couldn't":"could not",
"couldn't've":"could not have",
"could've":"could have",
"daren't":"dare not",
"daresn't":"dare not",
"dasn't":"dare not",
"didn't":"did not",
"doesn't":"does not",
"don't":"do not",
"e'er":"ever",
"em":"them",
"everyone's":"everyone is",
"finna":"fixing to",
"gimme":"give me",
"gonna":"going to",
"gon't":"go not",
"gotta":"got to",
"hadn't":"had not",
"hasn't":"has not",
"haven't":"have not",
"he'd":"he would",
"he'll":"he will",
"he's":"he is",
"he've":"he have",
"how'd":"how would",
"how'll":"how will",
"how're":"how are",
"how's":"how is",
"I'd":"I would",
"I'll":"I will",
"i'll":"I will",
"I'm":"I am",
"I'm'a":"I am about to",
"I'm'o":"I am going to",
"isn't":"is not",
"it'd":"it would",
"it'll":"it will",
"it's":"it is",
"I've":"I have",
"kinda":"kind of",
"let's":"let us",
"mayn't":"may not",
"may've":"may have",
"mightn't":"might not",
"might've":"might have",
"mustn't":"must not",
"mustn't've":"must not have",
"must've":"must have",
"needn't":"need not",
"ne'er":"never",
"o'":"of",
"o'er":"over",
"ol'":"old",
"oughtn't":"ought not",
"shalln't":"shall not",
"shan't":"shall not",
"she'd":"she would",
"she'll":"she will",
"she's":"she is",
"shouldn't":"should not",
"shouldn't've":"should not have",
"should've":"should have",
"somebody's":"somebody is",
"someone's":"someone is",
"something's":"something is",
"that'd":"that would",
"that'll":"that will",
"that're":"that are",
"that's":"that is",
"there'd":"there would",
"there'll":"there will",
"there're":"there are",
"there's":"there is",
"these're":"these are",
"they'd":"they would",
"they'll":"they will",
"they're":"they are",
"they've":"they have",
"this's":"this is",
"those're":"those are",
"'tis":"it is",
"'twas":"it was",
"wanna":"want to",
"wasn't":"was not",
"we'd":"we would",
"we'd've":"we would have",
"we'll":"we will",
"we're":"we are",
"weren't":"were not",
"we've":"we have",
"what'd":"what did",
"what'll":"what will",
"what're":"what are",
"what's":"what is",
"what've":"what have",
"when's":"when is",
"where'd":"where did",
"where're":"where are",
"where's":"where is",
"where've":"where have",
"which's":"which is",
"who'd":"who would",
"who'd've":"who would have",
"who'll":"who will",
"who're":"who are",
"who's":"who is",
"who've":"who have",
"why'd":"why did",
"why're":"why are",
"why's":"why is",
"won't":"will not",
"wouldn't":"would not",
"would've":"would have",
"y'all":"you all",
"you'd":"you would",
"you'll":"you will",
"you're":"you are",
"you've":"you have",
"Whatcha":"What are you",
"whatcha":"What are you",
"luv":"love",
"sux":"sucks"
}
'''
Handling short forms and contractions in the sentences
'''
long_form_dict = load_dict_contractions()
def
|
(sentence):
final_sent =""
res = " ".join(long_form_dict.get(ele, ele) for ele in sentence.split())
for word in res.split():
final_sent += (handle_short_forms(word))+ " "
return final_sent
data.shape
l=[]
for sent in data.sentence_eng:
l.append(expand_sent(sent))
print(l[2:5])
data['sentence_eng']=l
'''
Emoticon processing
'''
emoji_list = pd.read_csv('emoji.csv',sep=",")
def find_emoji(sentence):
positive = 0
negative = 0
neutral = 0
sentiment =[]
for word in sentence.split():
if not emoji_list[emoji_list['Emoji']==word].empty:
positive += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Positive']
negative += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Negative']
neutral += emoji_list.iloc[emoji_list.index[emoji_list['Emoji'] == word].tolist()[0]]['Neutral']
return positive,negative,neutral
'''
Slang word processing
'''
slang_list = pd.read_csv('Hinglish_Profanity_List.csv',sep=",",header=None)
slang_list.columns=['hindi_word','meaning','rating']
def find_slang(sentence):
slang_exists = False
total_rating = 0
for word in sentence.split():
if not slang_list[slang_list['hindi_word']==word].empty:
try:
total_rating += slang_list.iloc[slang_list.index[slang_list['hindi_word'] == word].tolist()[0]]['rating']
except:
total_rating +=0
slang_exists = True
try:
total_rating = int(total_rating)
except:
total_rating = 0
return slang_exists,total_rating
data['slang_exists']= data['sentence_mixed'].apply(find_slang)
data[['slang_existance', 'slang_rating']] = pd.DataFrame(data['slang_exists'].tolist(), index=data.index)
data =data.drop(columns=['slang_exists'])
data['emoji_sentiment'] = data['sentence_mixed'].apply(find_emoji)
data[['positive_emoji', 'negative_emoji','neutral_emoji']] = pd.DataFrame(data['emoji_sentiment'].tolist(), index=data.index)
data =data.drop(columns=['emoji_sentiment'])
'''
Calculating the sentiment polarity score
'''
sid = SentimentIntensityAnalyzer()
neg_score=[]
pos_score=[]
neu_score=[]
for sent in data.sentence_eng:
ss = sid.polarity_scores(sent)
neg_score.append(ss['neg'])
pos_score.append(ss['pos'])
neu_score.append(ss['neu'])
data['neg_score']= neg_score
data['pos_score']= pos_score
data['neu_score']= neu_score
data.tail(10)
# removing unwanted patterns from the data
import re
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords
from nltk.stem.porter import PorterStemmer
#Splitting the data
train = data[:5000]
test = data[5000:]
'''
fetching the sentence/comments from the test dataset and cleaning it
'''
train_corpus = []
for i in range(0, 5000):
review = re.sub('[^a-zA-Z]', ' ', train['sentence_eng'][i])
review = review.lower()
review = review.split()
ps = PorterStemmer()
# stemming
review = [ps.stem(word) for word in review if not word in set(stopwords.words('english'))]
# joining them back with space
review = ' '.join(review)
train_corpus.append(review)
'''
fetching the sentence/comments from the test dataset and cleaning it
'''
test_corpus = []
for i in range(5000, 6137):
review = re.sub('[^a-zA-Z]', ' ', test['sentence
|
expand_sent
|
identifier_name
|
main.py
|
msg': 'Requisição enviada para aprovação!'}
else:
json_ret = {'status': 500, 'msg': msg}
else:
json_ret = {'status': 500, 'msg': 'Json inválido!'}
return json_ret
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
def delete_card_request_handler(event, context):
"""
DELETE - Esse código será chamado através de um DELETE para a API que será criada no arquivo serverless.
Faz a requisição para apagar uma solicitação de cartão.
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: JSON contendo informações sobre a solicitação realizada, se o pedido de cartão foi excluído ou não.
"""
try:
s3_bucket_crawler = getenv('S3_BUCKET', '')
request_json, msg = None, None
path = event.get('path', {})
if 'id' in path.keys():
s3 = S3(s3_bucket_crawler)
s3.create_s3_instance()
del_response, msg = s3.delete_s3_obj('', path['id'])
if del_response['ResponseMetadata']['HTTPStatusCode'] == 204:
return {'status': 200, 'msg': 'Requisição deletada!'}
else:
return {'status': 404, 'msg': 'Requisição não encontrado'}
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
def process_card_request_handler(event, context):
"""
Realiza o processamento de um pedido de novo cartão.
Esse código é ativado quando um novo arquivo de pedido é salvo no S3
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: None.
"""
try:
for obj in event['Records']:
# Informações do arquivo que foi inserido no S3
bucket_name = obj['s3']['bucket']['name']
obj = obj['s3']['object']['key']
s3 = S3(bucket_name)
s3.create_s3_instance()
obj_json, msg = s3.get_s3_obj('', obj)
# faz os Score do cliente
score = randint(1, 999)
obj_json['credit'] = score_to_text(score, obj_json['income'])
resp, msg = s3.put_s3_obj('', obj_json, obj_json['cpf'])
except Exception as err:
print({'status': 500, 'msg': 'Erro interno ao processar a requisição', "error": f'{err}'})
def get_new_card_request_response_handler(event, context):
"""
GET - Esse código será chamado através de um GET para a API que será criada no arquivo serverless.
Recebe o id do solicitante via parametro de URL e retorna as informações referente ao solicitante e seu crédito
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: informações do solicitante
"""
try:
s3_bucket_crawler = getenv('S3_BUCKET', '')
print(event)
request_json, msg = None, None
path = event.get('path', {})
if 'id' in path.keys():
s3 = S3(s3_bucket_crawler)
s3.create_s3_instance()
request_json, msg = s3.get_s3_obj('', path['id'])
if request_json:
request_json['status'] = 200
return request_json
else:
return {'status': 404, 'msg': 'Requisição não encontrada'}
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
if __name__ == '__main__':
ex_event = {'body':
{
'name': 'Leonardo Roberto Gazziro',
'phone': '99999999999',
'age': 26,
'cpf': '999.999.999-99',
'income': 3000
},
'method': 'POST', 'principalId': '',
'stage': 'dev',
'cognitoPoolClaims': {'sub': ''},
'enhancedAuthContext': {},
'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate, br',
'Cache-Control': 'no-cache', 'CloudFront-Forwarded-Proto': 'https',
'CloudFront-Is-Desktop-Viewer': 'true',
'CloudFront-Is-Mobile-Viewer': 'false',
'CloudFront-Is-SmartTV-Viewer': 'false',
'CloudFront-Is-Tablet-Viewer': 'false',
'CloudFront-Viewer-Country': 'BR',
'Content-Type': 'application/json',
'Host': '1nhucniq8b.execute-api.us-east-1.amazonaws.com',
'Postman-Token': '0d40ddc9-494c-438c-9e34-30f9f44ea018',
'User-Agent': 'PostmanRuntime/7.26.3',
'Via': '1.1 3fff6e22f8d6795a61bfdca17d362ca5.cloudfront.net (CloudFront)',
'X-Amz-Cf-Id': 'OKNx6jkzKLQ3nbtD0t4JTNynGlc2TZDSemAepsPC-8Kv0ZV1f6Tz7w==',
'X-Amzn-Trace-Id': 'Root=1-5f4bf435-7d8aa2621cebaaabfa719a0c',
'X-Forwarded-For': '138.204.24.213, 64.252.179.69',
'X-Forwarded-Port': '443', 'X-Forwarded-Proto': 'https'},
'query': {},
'path': {},
'identity': {'cognitoIdentityPoolId': '', 'accountId': '', 'cognitoIdentityId': '', 'caller': '',
'sourceIp': '138.204.24.213', 'principalOrgId': '', 'accessKey': '',
'cognitoAuthenticationType': '', 'cognitoAuthenticationProvider': '', 'userArn': '',
'userAgent': 'PostmanRuntime/7.26.3', 'user': ''},
'stageVariables': {},
'requestPath': ''}
ex_event_s3 = {'Records': [{'eventVersion': '2.1', 'eventSource': 'aws:s3', 'awsRegion': 'us-east-1',
'eventTime': '2020-09-06T18:11:57.722Z', 'eventName': 'ObjectCreated:Put',
'userIdentity': {'principalId': 'A1GN6EPM0JKA8K'},
'requestParameters': {'sourceIPAddress': '177.42.49.149'},
'responseElements': {'x-amz-request-id': '7857E87B7E4BA60D',
'x-amz-id-2': 'lmNysI3mKLmMQoOzCtPnjT8usl2fMUYbIyipfE59v3oWuyu44XxI/L2tXxRPkqjC6uUNu3rGB/eekMpWqOj6RceGfrLLLTeg'},
's3': {'s3SchemaVersion': '1.0',
'configurationId': 'cc7a7b1c-d354-413c-94e0-c4c2e3cf153a',
'bucket': {'name': 'cards-requests-leogazziro',
'ownerIdentity': {'principalId': 'A1GN6EPM0JKA8K'},
'arn': 'arn:aws:s3:::novo-produto'},
'object': {'key': '999.999.999-99.json', 'size': 1172,
'eTag': 'f64c165d9209eb645b660f04b27dc8d2',
'sequencer': '005F552670F6AF15F4'}}}]}
ex_event_att_price = {'body': {},
'method': 'GET',
|
'principalId': '',
'stage': 'dev',
'cognitoPoolClaims': {'sub': ''},
'enhancedAuthContext': {},
|
random_line_split
|
|
main.py
|
'msg': 'Erro interno ao processar a requisição'}
def request_new_card_handler(event, context):
"""
POST - Esse código se
|
print(msg)
json_ret = {'status': 200, 'msg': 'Requisição enviada para aprovação!'}
else:
json_ret = {'status': 500, 'msg': msg}
else:
json_ret = {'status': 500, 'msg': 'Json inválido!'}
return json_ret
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
def delete_card_request_handler(event, context):
"""
DELETE - Esse código será chamado através de um DELETE para a API que será criada no arquivo serverless.
Faz a requisição para apagar uma solicitação de cartão.
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: JSON contendo informações sobre a solicitação realizada, se o pedido de cartão foi excluído ou não.
"""
try:
s3_bucket_crawler = getenv('S3_BUCKET', '')
request_json, msg = None, None
path = event.get('path', {})
if 'id' in path.keys():
s3 = S3(s3_bucket_crawler)
s3.create_s3_instance()
del_response, msg = s3.delete_s3_obj('', path['id'])
if del_response['ResponseMetadata']['HTTPStatusCode'] == 204:
return {'status': 200, 'msg': 'Requisição deletada!'}
else:
return {'status': 404, 'msg': 'Requisição não encontrado'}
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
def process_card_request_handler(event, context):
"""
Realiza o processamento de um pedido de novo cartão.
Esse código é ativado quando um novo arquivo de pedido é salvo no S3
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: None.
"""
try:
for obj in event['Records']:
# Informações do arquivo que foi inserido no S3
bucket_name = obj['s3']['bucket']['name']
obj = obj['s3']['object']['key']
s3 = S3(bucket_name)
s3.create_s3_instance()
obj_json, msg = s3.get_s3_obj('', obj)
# faz os Score do cliente
score = randint(1, 999)
obj_json['credit'] = score_to_text(score, obj_json['income'])
resp, msg = s3.put_s3_obj('', obj_json, obj_json['cpf'])
except Exception as err:
print({'status': 500, 'msg': 'Erro interno ao processar a requisição', "error": f'{err}'})
def get_new_card_request_response_handler(event, context):
"""
GET - Esse código será chamado através de um GET para a API que será criada no arquivo serverless.
Recebe o id do solicitante via parametro de URL e retorna as informações referente ao solicitante e seu crédito
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: informações do solicitante
"""
try:
s3_bucket_crawler = getenv('S3_BUCKET', '')
print(event)
request_json, msg = None, None
path = event.get('path', {})
if 'id' in path.keys():
s3 = S3(s3_bucket_crawler)
s3.create_s3_instance()
request_json, msg = s3.get_s3_obj('', path['id'])
if request_json:
request_json['status'] = 200
return request_json
else:
return {'status': 404, 'msg': 'Requisição não encontrada'}
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
if __name__ == '__main__':
ex_event = {'body':
{
'name': 'Leonardo Roberto Gazziro',
'phone': '99999999999',
'age': 26,
'cpf': '999.999.999-99',
'income': 3000
},
'method': 'POST', 'principalId': '',
'stage': 'dev',
'cognitoPoolClaims': {'sub': ''},
'enhancedAuthContext': {},
'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate, br',
'Cache-Control': 'no-cache', 'CloudFront-Forwarded-Proto': 'https',
'CloudFront-Is-Desktop-Viewer': 'true',
'CloudFront-Is-Mobile-Viewer': 'false',
'CloudFront-Is-SmartTV-Viewer': 'false',
'CloudFront-Is-Tablet-Viewer': 'false',
'CloudFront-Viewer-Country': 'BR',
'Content-Type': 'application/json',
'Host': '1nhucniq8b.execute-api.us-east-1.amazonaws.com',
'Postman-Token': '0d40ddc9-494c-438c-9e34-30f9f44ea018',
'User-Agent': 'PostmanRuntime/7.26.3',
'Via': '1.1 3fff6e22f8d6795a61bfdca17d362ca5.cloudfront.net (CloudFront)',
'X-Amz-Cf-Id': 'OKNx6jkzKLQ3nbtD0t4JTNynGlc2TZDSemAepsPC-8Kv0ZV1f6Tz7w==',
'X-Amzn-Trace-Id': 'Root=1-5f4bf435-7d8aa2621cebaaabfa719a0c',
'X-Forwarded-For': '138.204.24.213, 64.252.179.69',
'X-Forwarded-Port': '443', 'X-Forwarded-Proto': 'https'},
'query': {},
'path': {},
'identity': {'cognitoIdentityPoolId': '', 'accountId': '', 'cognitoIdentityId': '', 'caller': '',
'sourceIp': '138.204.24.213', 'principalOrgId': '', 'accessKey': '',
'cognitoAuthenticationType': '', 'cognitoAuthenticationProvider': '', 'userArn': '',
'userAgent': 'PostmanRuntime/7.26.3', 'user': ''},
'stageVariables': {},
'requestPath': ''}
ex_event_s3 = {'Records': [{'eventVersion': '2.1', 'eventSource': 'aws:s3', 'awsRegion': 'us-east-1',
'eventTime': '2020-09-06T18:11:57.722Z', 'eventName': 'ObjectCreated:Put',
'userIdentity': {'principalId': 'A1GN6EPM0JKA8K'},
'requestParameters': {'sourceIPAddress': '177.42.49.149'},
'responseElements': {'x-amz-request-id': '7857E87B7E4BA60D',
'x-amz-id-2': 'lmNysI3mKLmMQoOzCtPnjT8usl2fMUYbIyipfE59v3oWuyu44XxI/L2tXxRPkqjC6uUNu3rGB/eekMpWq
|
rá chamado através de um POST para a API que será criada no arquivo serverless.
Faz a requisição de um novo cartão, o Score do candidato será avaliado.
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: JSON contendo informações sobre a solicitação realizada, se o pedido de cartão foi aprovado ou não.
"""
try:
body = event.get('body', {})
s3_bucket = getenv('S3_BUCKET', '')
if body:
# Verifica se o JSON é valido
json_valido, msg = valid_new_card_request(body)
if json_valido:
body['id'] = str(uuid.uuid4())
s3 = S3(s3_bucket)
s3.create_s3_instance()
# insere o JSON no S3
resp, msg = s3.put_s3_obj('', body, body['cpf'])
print(resp)
|
identifier_body
|
main.py
|
r:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
def request_new_card_handler(event, context):
"""
POST - Esse código será chamado através de um POST para a API que será criada no arquivo serverless.
Faz a requisição de um novo cartão, o Score do candidato será avaliado.
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: JSON contendo informações sobre a solicitação realizada, se o pedido de cartão foi aprovado ou não.
"""
try:
body = event.get('body', {})
s3_bucket = getenv('S3_BUCKET', '')
if body:
# Verifica se o JSON é valido
json_valido, msg = valid_new_card_request(body)
if json_valido:
body['id'] = str(uuid.uuid4())
s3 = S3(s3_bucket)
s3.create_s3_instance()
# insere o JSON no S3
resp, msg = s3.put_s3_obj('', body, body['cpf'])
print(resp)
print(msg)
json_ret = {'status': 200, 'msg': 'Requisição enviada para aprovação!'}
else:
json_ret = {'status': 500, 'msg': msg}
else:
json_ret = {'status': 500, 'msg': 'Json inválido!'}
return json_ret
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
def delete_card_request_handler(event, context):
"""
DELETE - Esse código será chamado através de um DELETE para a API que será criada no arquivo serverless.
Faz a requisição para apagar uma solicitação de cartão.
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: JSON contendo informações sobre a solicitação realizada, se o pedido de cartão foi excluído ou não.
"""
try:
s3_bucket_crawler = getenv('S3_BUCKET', '')
request_json, msg = None, None
path = event.get('path', {})
if 'id' in path.keys():
s3 = S3(s3_bucket_crawler)
s3.create_s3_instance()
del_response, msg = s3.delete_s3_obj('', path['id'])
if del_response['ResponseMetadata']['HTTPStatusCode'] == 204:
return {'status': 200, 'msg': 'Requisição deletada!'}
else:
return {'status': 404, 'msg': 'Requisição não encontrado'}
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
def process_card_request_handler(event, context):
"""
Realiza o processamento de um pedido de novo cartão.
Esse código é ativado quando um novo arquivo de pedido é salvo no S3
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: None.
"""
try:
for obj in event['Records']:
# Informações do arquivo que foi inserido no S3
bucket_name = obj['s3']['bucket']['name']
obj = obj['s3']['object']['key']
s3 = S3(bucket_name)
s3.create_s3_instance()
obj_json, msg = s3.get_s3_obj('', obj)
# faz os Score do cliente
score = randint(1, 999)
obj_json['credit'] = score_to_text(score, obj_json['income'])
resp, msg = s3.put_s3_obj('', obj_json, obj_json['cpf'])
except Exception as err:
print({'status': 500, 'msg': 'Erro interno ao processar a requisição', "error": f'{err}'})
def get_new_card_request_response_handler(event, context):
"""
GET - Esse código será chamado através de um GET para a API que será criada no arquivo serverless.
Recebe o id do solicitante via parametro de URL e retorna as informações referente ao solicitante e seu crédito
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: informações do solicitante
"""
try:
s3_bucket_crawler = getenv('S3_BUCKET', '')
print(event)
request_json, msg = None, None
path = event.get('path', {})
if 'id' in path.keys():
s3 = S3(s3_bucket_crawler)
s3.create_s3_instance()
request_json, msg = s3.get_s3_obj('', path['id'])
if request_json:
request_json['status'] = 200
return request_json
else:
return {'status': 404, 'msg': 'Requisição não encontrada'}
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
if __name__ == '__main__':
ex_event = {'body':
{
'name': 'Leonardo Roberto Gazziro',
'phone': '99999999999',
'age': 26,
'cpf': '999.999.999-99',
'income': 3000
},
'method': 'POST', 'principalId': '',
'stage': 'dev',
'cognitoPoolClaims': {'sub': ''},
'enhancedAuthContext': {},
'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate, br',
'Cache-Control': 'no-cache', 'CloudFront-Forwarded-Proto': 'https',
'CloudFront-Is-Desktop-Viewer': 'true',
'CloudFront-Is-Mobile-Viewer': 'false',
'CloudFront-Is-SmartTV-Viewer': 'false',
'CloudFront-Is-Tablet-Viewer': 'false',
'CloudFront-Viewer-Country': 'BR',
'Content-Type': 'application/json',
'Host': '1nhucniq8b.execute-api.us-east-1.amazonaws.com',
'Postman-Token': '0d40ddc9-494c-438c-9e34-30f9f44ea018',
'User-Agent': 'PostmanRuntime/7.26.3',
'Via': '1.1 3fff6e22f8d6795a61bfdca17d362ca5.cloudfront.net (CloudFront)',
'X-Amz-Cf-Id': 'OKNx6jkzKLQ3nbtD0t4JTNynGlc2TZDSemAepsPC-8Kv0ZV1f6Tz7w==',
'X-Amzn-Trace-Id': 'Root=1-5f4bf435-7d8aa2621cebaaabfa719a0c',
'X-Forwarded-For': '138.204.24.213, 64.252.179.69',
'X-Forwarded-Port': '443', 'X-Forwarded-Proto': 'https'},
'query': {},
'path': {},
'identity': {'cognitoIdentityPoolId': '', 'accountId': '', 'cognitoIdentityId': '', 'caller': '',
'sourceIp': '138.204.24.213', 'principalOrgId': '', 'accessKey': '',
'cognitoAuthenticationType': '', 'cognitoAuthenticationProvider': '', 'userArn': '',
'userAgent': 'PostmanRuntime/7.26.3', 'user': ''},
'stageVariables': {},
'requestPath': ''}
ex_event_s3 = {'Records': [{'eventVersion': '2.1', 'eventSource': 'aws:s3', 'awsRegion': 'us-east-1',
'eventTime': '2020-09-06T18:11:57.722Z', 'eventName': 'ObjectCreated:Put',
'userIdentity': {'principalId': 'A1GN6EPM0JKA8K'},
'requestParameters': {'sourceIPAddress': '177.42.49.149'},
'responseElements': {'x-amz-request-id': '7857E87B7E4BA60D',
'x-amz-id-2': 'lmNysI3mKLmMQoOzCtPnjT8usl2fMUYbIyipfE59v3oW
|
msg': 'Lista de requisições não encontrada'}
except Exception as er
|
conditional_block
|
|
main.py
|
'msg': 'Erro interno ao processar a requisição'}
def request_new_card_handler(event, context):
"""
POST - Esse código será chamado através de um POST para a API que será criada no arquivo serverless.
Faz a requisição de um novo cartão, o Score do candidato será avaliado.
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: JSON contendo informações sobre a solicitação realizada, se o pedido de cartão foi aprovado ou não.
"""
try:
body = event.get('body', {})
s3_bucket = getenv('S3_BUCKET', '')
if body:
# Verifica se o JSON é valido
json_valido, msg = valid_new_card_request(body)
if json_valido:
body['id'] = str(uuid.uuid4())
s3 = S3(s3_bucket)
s3.create_s3_instance()
# insere o JSON no S3
resp, msg = s3.put_s3_obj('', body, body['cpf'])
print(resp)
print(msg)
json_ret = {'status': 200, 'msg': 'Requisição enviada para aprovação!'}
else:
json_ret = {'status': 500, 'msg': msg}
else:
json_ret = {'status': 500, 'msg': 'Json inválido!'}
return json_ret
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
def delete_card_request_handler(event, context):
"""
DELETE - Esse código será chamado através de um DELETE para a API que será criada no arquivo serverless.
Faz a requisição para apagar uma solicitação de cartão.
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: JSON contendo informações sobre a solicitação realizada, se o pedido de cartão foi excluído ou não.
"""
try:
s3_bucket_crawler = getenv('S3_BUCKET', '')
request_json, msg = None, None
path = event.get('path', {})
if 'id' in path.keys():
s3 = S3(s3_bucket_crawler)
s3.create_s3_instance()
del_response, msg = s3.delete_s3_obj('', path['id'])
if del_response['ResponseMetadata']['HTTPStatusCode'] == 204:
return {'status': 200, 'msg': 'Requisição deletada!'}
else:
return {'status': 404, 'msg': 'Requisição não encontrado'}
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
def process_card_request_handler(event, context):
"""
Realiza o processamento de um pedido de novo cartão.
Esse código é ativado quando um novo arquivo de pedido é salvo no S3
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: None.
"""
try:
for obj in event['Records']:
# Informações do arquivo que foi inserido no S3
bucket_name = obj['s3']['bucket']['name']
obj = obj['s3']['object']['key']
s3 = S3(bucket_name)
s3.create_s3_instance()
obj_json, msg = s3.get_s3_obj('', obj)
# faz os Score do cliente
score = randint(1, 999)
obj_json['credit'] = score_to_text(score, obj_json['income'])
resp, msg = s3.put_s3_obj('', obj_json, obj_json['cpf'])
except Exception as err:
print({'status': 500, 'msg': 'Erro interno ao processar a requisição', "error": f'{err}'})
def get_new_card_request_response_handler(event, context):
"""
GET - Esse código será cham
|
será criada no arquivo serverless.
Recebe o id do solicitante via parametro de URL e retorna as informações referente ao solicitante e seu crédito
:param event: Event recebido pela nuvem
:param context: Contexto com informações da função
:return: informações do solicitante
"""
try:
s3_bucket_crawler = getenv('S3_BUCKET', '')
print(event)
request_json, msg = None, None
path = event.get('path', {})
if 'id' in path.keys():
s3 = S3(s3_bucket_crawler)
s3.create_s3_instance()
request_json, msg = s3.get_s3_obj('', path['id'])
if request_json:
request_json['status'] = 200
return request_json
else:
return {'status': 404, 'msg': 'Requisição não encontrada'}
except Exception as err:
return {'status': 500, 'msg': 'Erro interno ao processar a requisição'}
if __name__ == '__main__':
ex_event = {'body':
{
'name': 'Leonardo Roberto Gazziro',
'phone': '99999999999',
'age': 26,
'cpf': '999.999.999-99',
'income': 3000
},
'method': 'POST', 'principalId': '',
'stage': 'dev',
'cognitoPoolClaims': {'sub': ''},
'enhancedAuthContext': {},
'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate, br',
'Cache-Control': 'no-cache', 'CloudFront-Forwarded-Proto': 'https',
'CloudFront-Is-Desktop-Viewer': 'true',
'CloudFront-Is-Mobile-Viewer': 'false',
'CloudFront-Is-SmartTV-Viewer': 'false',
'CloudFront-Is-Tablet-Viewer': 'false',
'CloudFront-Viewer-Country': 'BR',
'Content-Type': 'application/json',
'Host': '1nhucniq8b.execute-api.us-east-1.amazonaws.com',
'Postman-Token': '0d40ddc9-494c-438c-9e34-30f9f44ea018',
'User-Agent': 'PostmanRuntime/7.26.3',
'Via': '1.1 3fff6e22f8d6795a61bfdca17d362ca5.cloudfront.net (CloudFront)',
'X-Amz-Cf-Id': 'OKNx6jkzKLQ3nbtD0t4JTNynGlc2TZDSemAepsPC-8Kv0ZV1f6Tz7w==',
'X-Amzn-Trace-Id': 'Root=1-5f4bf435-7d8aa2621cebaaabfa719a0c',
'X-Forwarded-For': '138.204.24.213, 64.252.179.69',
'X-Forwarded-Port': '443', 'X-Forwarded-Proto': 'https'},
'query': {},
'path': {},
'identity': {'cognitoIdentityPoolId': '', 'accountId': '', 'cognitoIdentityId': '', 'caller': '',
'sourceIp': '138.204.24.213', 'principalOrgId': '', 'accessKey': '',
'cognitoAuthenticationType': '', 'cognitoAuthenticationProvider': '', 'userArn': '',
'userAgent': 'PostmanRuntime/7.26.3', 'user': ''},
'stageVariables': {},
'requestPath': ''}
ex_event_s3 = {'Records': [{'eventVersion': '2.1', 'eventSource': 'aws:s3', 'awsRegion': 'us-east-1',
'eventTime': '2020-09-06T18:11:57.722Z', 'eventName': 'ObjectCreated:Put',
'userIdentity': {'principalId': 'A1GN6EPM0JKA8K'},
'requestParameters': {'sourceIPAddress': '177.42.49.149'},
'responseElements': {'x-amz-request-id': '7857E87B7E4BA60D',
'x-amz-id-2': 'lmNysI3mKLmMQoOzCtPnjT8usl2fMUYbIyipfE59v3oWuyu44XxI/L2tXxRPkqjC6uUNu3rGB/eekMpW
|
ado através de um GET para a API que
|
identifier_name
|
config.go
|
created: %v", cfg)
return cfg
}
// EmptyConfig creates a Config with no services or groups
func EmptyConfig(workingDir string) Config {
log.Printf("Creating empty config\n")
cfg := Config{
workingDir: workingDir,
}
cfg.ServiceMap = make(map[string]*services.ServiceConfig)
cfg.GroupMap = make(map[string]*services.ServiceGroupConfig)
return cfg
}
// NormalizeServicePaths will modify the Paths for each of the provided services
// to be relative to the working directory of this config file
func (c *Config) NormalizeServicePaths(searchPath string, newServices []*services.ServiceConfig) ([]*services.ServiceConfig, error) {
log.Printf("Normalizing paths for %d services.\n", len(newServices))
var outServices []*services.ServiceConfig
for _, s := range newServices {
curService := *s
fullPath := filepath.Join(searchPath, *curService.Path)
relPath, err := filepath.Rel(c.workingDir, fullPath)
if err != nil {
return outServices, errors.WithStack(err)
}
curService.Path = &relPath
outServices = append(outServices, &curService)
}
return outServices, nil
}
// AppendServices adds services to an existing config without replacing existing services
func (c *Config) AppendServices(newServices []*services.ServiceConfig) error {
log.Printf("Appending %d services.\n", len(newServices))
if c.ServiceMap == nil {
c.ServiceMap = make(map[string]*services.ServiceConfig)
}
for _, s := range newServices {
if _, found := c.ServiceMap[s.Name]; !found {
c.ServiceMap[s.Name] = s
c.Services = append(c.Services, *s)
}
}
return nil
}
// AppendGroups adds groups to an existing config without replacing existing groups
func (c *Config) AppendGroups(groups []*services.ServiceGroupConfig) error {
var groupsDereferenced []services.ServiceGroupConfig
for _, group := range groups {
groupsDereferenced = append(groupsDereferenced, *group)
}
return errors.WithStack(c.AddGroups(groupsDereferenced))
}
func (c *Config) RemoveGroup(name string) error {
if _, ok := c.GroupMap[name]; !ok {
return errors.New("Group not found")
}
delete(c.GroupMap, name)
existingGroupDefs := c.Groups
c.Groups = make([]GroupDef, 0, len(existingGroupDefs))
for _, group := range existingGroupDefs {
if group.Name != name {
c.Groups = append(c.Groups, group)
}
}
return nil
}
// AddGroups adds a slice of groups to the Config
func (c *Config) AddGroups(groups []services.ServiceGroupConfig) error {
log.Printf("Adding %d groups.\n", len(groups))
for _, group := range groups {
grp := GroupDef{
Name: group.Name,
Aliases: group.Aliases,
Description: group.Description,
Children: []string{},
Env: group.Env,
}
for _, cg := range group.Groups {
if cg != nil {
grp.Children = append(grp.Children, cg.Name)
}
}
for _, cs := range group.Services {
if cs != nil {
grp.Children = append(grp.Children, cs.Name)
}
}
c.Groups = append(c.Groups, grp)
}
return nil
}
func (c *Config) loadImports() error {
log.Printf("Loading imports\n")
for _, i := range c.Imports {
var cPath string
if filepath.IsAbs(i) {
cPath = i
} else {
cPath = filepath.Join(c.workingDir, i)
}
log.Printf("Loading: %v\n", cPath)
r, err := os.Open(cPath)
if err != nil {
return errors.WithStack(err)
}
cfg, err := loadConfigContents(r, filepath.Dir(cPath))
if err != nil {
return errors.WithMessage(err, i)
}
err = c.importConfig(cfg)
if err != nil {
return errors.WithStack(err)
}
}
return nil
}
func (c *Config) importConfig(second Config) error {
for _, service := range append(second.Services, second.ImportedServices...) {
c.ImportedServices = append(c.ImportedServices, service)
}
for _, group := range append(second.Groups, second.ImportedGroups...) {
c.ImportedGroups = append(c.ImportedGroups, group)
}
return nil
}
func (c *Config) combinePath(path string) *string {
if filepath.IsAbs(path) || strings.HasPrefix(path, "$") {
return &path
}
fullPath := filepath.Join(c.workingDir, path)
return &fullPath
}
func addToMap(m map[string]struct{}, values ...string) {
for _, v := range values {
m[v] = struct{}{}
}
}
func intersect(m map[string]struct{}, values ...string) []string {
var out []string
for _, v := range values {
if _, ok := m[v]; ok {
out = append(out, v)
}
}
sort.Strings(out)
return out
}
func (c *Config) initMaps() error {
var err error
var svcs = make(map[string]*services.ServiceConfig)
var servicesSkipped = make(map[string]struct{})
var namesInUse = make(map[string]struct{})
for _, s := range append(c.Services, c.ImportedServices...) {
sc := s
sc.Env = append(sc.Env, c.Env...)
sc.ConfigFile, err = filepath.Abs(c.FilePath)
if err != nil {
return errors.WithStack(err)
}
if sc.MatchesPlatform() {
if i := intersect(namesInUse, append(sc.Aliases, sc.Name)...); len(i) > 0 {
return fmt.Errorf("Duplicate name or alias: %v", strings.Join(i, ", "))
}
svcs[sc.Name] = &sc
addToMap(namesInUse, append(sc.Aliases, sc.Name)...)
} else {
servicesSkipped[sc.Name] = struct{}{}
}
}
var groups = make(map[string]*services.ServiceGroupConfig)
// First pass: Services
var orphanNames = make(map[string]struct{})
for _, g := range append(c.Groups, c.ImportedGroups...) {
var childServices []*services.ServiceConfig
for _, name := range g.Children {
if s, ok := svcs[name]; ok {
if s.Path != nil {
s.Path = c.combinePath(*s.Path)
}
childServices = append(childServices, s)
} else if _, skipped := servicesSkipped[name]; !skipped {
orphanNames[name] = struct{}{}
}
}
if i := intersect(namesInUse, append(g.Aliases, g.Name)...); len(i) > 0 {
return fmt.Errorf("Duplicate name or alias: %v", strings.Join(i, ", "))
}
groups[g.Name] = &services.ServiceGroupConfig{
Name: g.Name,
Aliases: g.Aliases,
Description: g.Description,
Services: childServices,
Groups: []*services.ServiceGroupConfig{},
Env: g.Env,
ChildOrder: g.Children,
}
addToMap(namesInUse, append(g.Aliases, g.Name)...)
}
// Second pass: Groups
for _, g := range append(c.Groups, c.ImportedGroups...) {
childGroups := []*services.ServiceGroupConfig{}
for _, name := range g.Children {
if gr, ok := groups[name]; ok {
delete(orphanNames, name)
childGroups = append(childGroups, gr)
}
if hasChildCycle(groups[g.Name], childGroups) {
return errors.New("group cycle: " + g.Name)
}
}
groups[g.Name].Groups = childGroups
}
if len(orphanNames) > 0 {
var keys []string
for k := range orphanNames {
keys = append(keys, k)
}
return errors.New("A service or group could not be found for the following names: " + strings.Join(keys, ", "))
}
c.ServiceMap = svcs
c.GroupMap = groups
return nil
}
func hasChildCycle(parent *services.ServiceGroupConfig, children []*services.ServiceGroupConfig) bool {
for _, sg := range children {
if parent == sg {
return true
}
if hasChildCycle(parent, sg.Groups) {
return true
}
}
return false
}
func stringSliceIntersect(slices [][]string) []string {
var counts = make(map[string]int)
for _, s := range slices {
for _, v := range s {
counts[v]++
}
}
var outSlice []string
for v, count := range counts {
if count == len(slices) {
outSlice = append(outSlice, v)
}
}
return outSlice
}
func stringSliceRemoveCommon(common []string, original []string) []string {
var commonMap = make(map[string]interface{})
|
for _, s := range common {
commonMap[s] = struct{}{}
}
var outSlice []string
for _, s := range original {
|
random_line_split
|
|
config.go
|
)
if err != nil {
return Config{}, errors.WithStack(err)
}
workingDir := path.Dir(filePath)
config, err := loadConfigContents(reader, workingDir)
config.FilePath = filePath
if err != nil {
return Config{}, errors.WithStack(err)
}
if config.MinEdwardVersion != "" && edwardVersion != "" {
// Check that this config is supported by this version
minVersion, err1 := version.NewVersion(config.MinEdwardVersion)
if err1 != nil {
return Config{}, errors.WithStack(err)
}
currentVersion, err2 := version.NewVersion(edwardVersion)
if err2 != nil {
return Config{}, errors.WithStack(err)
}
if currentVersion.LessThan(minVersion) {
return Config{}, errors.New("this config requires at least version " + config.MinEdwardVersion)
}
}
err = config.initMaps()
log.Printf("Config loaded with: %d groups and %d services\n", len(config.GroupMap), len(config.ServiceMap))
return config, errors.WithStack(err)
}
// Reader from os.Open
func loadConfigContents(reader io.Reader, workingDir string) (Config, error) {
log.Printf("Loading config with working dir %v.\n", workingDir)
buf := new(bytes.Buffer)
_, err := buf.ReadFrom(reader)
if err != nil {
return Config{}, errors.Wrap(err, "could not read config")
}
data := buf.Bytes()
var config Config
err = json.Unmarshal(data, &config)
if err != nil {
if syntax, ok := err.(*json.SyntaxError); ok && syntax.Offset != 0 {
start := strings.LastIndex(string(data[:syntax.Offset]), "\n") + 1
line, pos := strings.Count(string(data[:start]), "\n")+1, int(syntax.Offset)-start-1
return Config{}, errors.Wrapf(err, "could not parse config file (line %v, char %v)", line, pos)
}
return Config{}, errors.Wrap(err, "could not parse config file")
}
config.workingDir = workingDir
err = config.loadImports()
if err != nil {
return Config{}, errors.WithStack(err)
}
return config, nil
}
// Save saves config to an io.Writer
func (c Config) Save(writer io.Writer) error {
log.Printf("Saving config")
content, err := json.MarshalIndent(c, "", " ")
if err != nil {
return errors.WithStack(err)
}
_, err = writer.Write(content)
return errors.WithStack(err)
}
// NewConfig creates a Config from slices of services and groups
func NewConfig(newServices []services.ServiceConfig, newGroups []services.ServiceGroupConfig) Config {
log.Printf("Creating new config with %d services and %d groups.\n", len(newServices), len(newGroups))
// Find Env settings common to all services
var allEnvSlices [][]string
for _, s := range newServices {
allEnvSlices = append(allEnvSlices, s.Env)
}
env := stringSliceIntersect(allEnvSlices)
// Remove common settings from services
var svcs []services.ServiceConfig
for _, s := range newServices {
s.Env = stringSliceRemoveCommon(env, s.Env)
svcs = append(svcs, s)
}
cfg := Config{
Env: env,
Services: svcs,
Groups: []GroupDef{},
}
cfg.AddGroups(newGroups)
log.Printf("Config created: %v", cfg)
return cfg
}
// EmptyConfig creates a Config with no services or groups
func EmptyConfig(workingDir string) Config {
log.Printf("Creating empty config\n")
cfg := Config{
workingDir: workingDir,
}
cfg.ServiceMap = make(map[string]*services.ServiceConfig)
cfg.GroupMap = make(map[string]*services.ServiceGroupConfig)
return cfg
}
// NormalizeServicePaths will modify the Paths for each of the provided services
// to be relative to the working directory of this config file
func (c *Config) NormalizeServicePaths(searchPath string, newServices []*services.ServiceConfig) ([]*services.ServiceConfig, error) {
log.Printf("Normalizing paths for %d services.\n", len(newServices))
var outServices []*services.ServiceConfig
for _, s := range newServices {
curService := *s
fullPath := filepath.Join(searchPath, *curService.Path)
relPath, err := filepath.Rel(c.workingDir, fullPath)
if err != nil {
return outServices, errors.WithStack(err)
}
curService.Path = &relPath
outServices = append(outServices, &curService)
}
return outServices, nil
}
// AppendServices adds services to an existing config without replacing existing services
func (c *Config) AppendServices(newServices []*services.ServiceConfig) error {
log.Printf("Appending %d services.\n", len(newServices))
if c.ServiceMap == nil {
c.ServiceMap = make(map[string]*services.ServiceConfig)
}
for _, s := range newServices {
if _, found := c.ServiceMap[s.Name]; !found {
c.ServiceMap[s.Name] = s
c.Services = append(c.Services, *s)
}
}
return nil
}
// AppendGroups adds groups to an existing config without replacing existing groups
func (c *Config) AppendGroups(groups []*services.ServiceGroupConfig) error {
var groupsDereferenced []services.ServiceGroupConfig
for _, group := range groups {
groupsDereferenced = append(groupsDereferenced, *group)
}
return errors.WithStack(c.AddGroups(groupsDereferenced))
}
func (c *Config) RemoveGroup(name string) error {
if _, ok := c.GroupMap[name]; !ok {
return errors.New("Group not found")
}
delete(c.GroupMap, name)
existingGroupDefs := c.Groups
c.Groups = make([]GroupDef, 0, len(existingGroupDefs))
for _, group := range existingGroupDefs {
if group.Name != name {
c.Groups = append(c.Groups, group)
}
}
return nil
}
// AddGroups adds a slice of groups to the Config
func (c *Config) AddGroups(groups []services.ServiceGroupConfig) error
|
c.Groups = append(c.Groups, grp)
}
return nil
}
func (c *Config) loadImports() error {
log.Printf("Loading imports\n")
for _, i := range c.Imports {
var cPath string
if filepath.IsAbs(i) {
cPath = i
} else {
cPath = filepath.Join(c.workingDir, i)
}
log.Printf("Loading: %v\n", cPath)
r, err := os.Open(cPath)
if err != nil {
return errors.WithStack(err)
}
cfg, err := loadConfigContents(r, filepath.Dir(cPath))
if err != nil {
return errors.WithMessage(err, i)
}
err = c.importConfig(cfg)
if err != nil {
return errors.WithStack(err)
}
}
return nil
}
func (c *Config) importConfig(second Config) error {
for _, service := range append(second.Services, second.ImportedServices...) {
c.ImportedServices = append(c.ImportedServices, service)
}
for _, group := range append(second.Groups, second.ImportedGroups...) {
c.ImportedGroups = append(c.ImportedGroups, group)
}
return nil
}
func (c *Config) combinePath(path string) *string {
if filepath.IsAbs(path) || strings.HasPrefix(path, "$") {
return &path
}
fullPath := filepath.Join(c.workingDir, path)
return &fullPath
}
func addToMap(m map[string]struct{}, values ...string) {
for _, v := range values {
m[v] = struct{}{}
}
}
func intersect(m map[string]struct{}, values ...string) []string {
var out []string
for _, v := range values {
if _, ok := m[v]; ok {
out = append(out, v)
}
}
sort.Strings(out)
return out
}
func (c *Config) initMaps() error {
var err error
var svcs = make(map[string]*services.ServiceConfig)
var servicesSkipped = make(map[string]struct{})
var namesInUse = make(map[string]struct{})
for _, s := range append(c.Services, c.ImportedServices...) {
sc := s
sc.Env = append(sc.Env, c.Env...)
sc.ConfigFile, err = filepath.Abs(c.FilePath)
if err != nil {
return errors.WithStack(err)
}
if sc.MatchesPlatform() {
if i := intersect(namesInUse, append(sc.Aliases, sc.Name)...); len(i) > 0 {
return fmt.Errorf("Duplicate name or alias: %v", strings.Join
|
{
log.Printf("Adding %d groups.\n", len(groups))
for _, group := range groups {
grp := GroupDef{
Name: group.Name,
Aliases: group.Aliases,
Description: group.Description,
Children: []string{},
Env: group.Env,
}
for _, cg := range group.Groups {
if cg != nil {
grp.Children = append(grp.Children, cg.Name)
}
}
for _, cs := range group.Services {
if cs != nil {
grp.Children = append(grp.Children, cs.Name)
}
}
|
identifier_body
|
config.go
|
)
if err != nil {
return Config{}, errors.WithStack(err)
}
workingDir := path.Dir(filePath)
config, err := loadConfigContents(reader, workingDir)
config.FilePath = filePath
if err != nil {
return Config{}, errors.WithStack(err)
}
if config.MinEdwardVersion != "" && edwardVersion != "" {
// Check that this config is supported by this version
minVersion, err1 := version.NewVersion(config.MinEdwardVersion)
if err1 != nil {
return Config{}, errors.WithStack(err)
}
currentVersion, err2 := version.NewVersion(edwardVersion)
if err2 != nil {
return Config{}, errors.WithStack(err)
}
if currentVersion.LessThan(minVersion) {
return Config{}, errors.New("this config requires at least version " + config.MinEdwardVersion)
}
}
err = config.initMaps()
log.Printf("Config loaded with: %d groups and %d services\n", len(config.GroupMap), len(config.ServiceMap))
return config, errors.WithStack(err)
}
// Reader from os.Open
func loadConfigContents(reader io.Reader, workingDir string) (Config, error) {
log.Printf("Loading config with working dir %v.\n", workingDir)
buf := new(bytes.Buffer)
_, err := buf.ReadFrom(reader)
if err != nil {
return Config{}, errors.Wrap(err, "could not read config")
}
data := buf.Bytes()
var config Config
err = json.Unmarshal(data, &config)
if err != nil {
if syntax, ok := err.(*json.SyntaxError); ok && syntax.Offset != 0 {
start := strings.LastIndex(string(data[:syntax.Offset]), "\n") + 1
line, pos := strings.Count(string(data[:start]), "\n")+1, int(syntax.Offset)-start-1
return Config{}, errors.Wrapf(err, "could not parse config file (line %v, char %v)", line, pos)
}
return Config{}, errors.Wrap(err, "could not parse config file")
}
config.workingDir = workingDir
err = config.loadImports()
if err != nil {
return Config{}, errors.WithStack(err)
}
return config, nil
}
// Save saves config to an io.Writer
func (c Config) Save(writer io.Writer) error {
log.Printf("Saving config")
content, err := json.MarshalIndent(c, "", " ")
if err != nil {
return errors.WithStack(err)
}
_, err = writer.Write(content)
return errors.WithStack(err)
}
// NewConfig creates a Config from slices of services and groups
func NewConfig(newServices []services.ServiceConfig, newGroups []services.ServiceGroupConfig) Config {
log.Printf("Creating new config with %d services and %d groups.\n", len(newServices), len(newGroups))
// Find Env settings common to all services
var allEnvSlices [][]string
for _, s := range newServices {
allEnvSlices = append(allEnvSlices, s.Env)
}
env := stringSliceIntersect(allEnvSlices)
// Remove common settings from services
var svcs []services.ServiceConfig
for _, s := range newServices {
s.Env = stringSliceRemoveCommon(env, s.Env)
svcs = append(svcs, s)
}
cfg := Config{
Env: env,
Services: svcs,
Groups: []GroupDef{},
}
cfg.AddGroups(newGroups)
log.Printf("Config created: %v", cfg)
return cfg
}
// EmptyConfig creates a Config with no services or groups
func EmptyConfig(workingDir string) Config {
log.Printf("Creating empty config\n")
cfg := Config{
workingDir: workingDir,
}
cfg.ServiceMap = make(map[string]*services.ServiceConfig)
cfg.GroupMap = make(map[string]*services.ServiceGroupConfig)
return cfg
}
// NormalizeServicePaths will modify the Paths for each of the provided services
// to be relative to the working directory of this config file
func (c *Config) NormalizeServicePaths(searchPath string, newServices []*services.ServiceConfig) ([]*services.ServiceConfig, error) {
log.Printf("Normalizing paths for %d services.\n", len(newServices))
var outServices []*services.ServiceConfig
for _, s := range newServices {
curService := *s
fullPath := filepath.Join(searchPath, *curService.Path)
relPath, err := filepath.Rel(c.workingDir, fullPath)
if err != nil {
return outServices, errors.WithStack(err)
}
curService.Path = &relPath
outServices = append(outServices, &curService)
}
return outServices, nil
}
// AppendServices adds services to an existing config without replacing existing services
func (c *Config) AppendServices(newServices []*services.ServiceConfig) error {
log.Printf("Appending %d services.\n", len(newServices))
if c.ServiceMap == nil {
c.ServiceMap = make(map[string]*services.ServiceConfig)
}
for _, s := range newServices {
if _, found := c.ServiceMap[s.Name]; !found {
c.ServiceMap[s.Name] = s
c.Services = append(c.Services, *s)
}
}
return nil
}
// AppendGroups adds groups to an existing config without replacing existing groups
func (c *Config) AppendGroups(groups []*services.ServiceGroupConfig) error {
var groupsDereferenced []services.ServiceGroupConfig
for _, group := range groups {
groupsDereferenced = append(groupsDereferenced, *group)
}
return errors.WithStack(c.AddGroups(groupsDereferenced))
}
func (c *Config) RemoveGroup(name string) error {
if _, ok := c.GroupMap[name]; !ok {
return errors.New("Group not found")
}
delete(c.GroupMap, name)
existingGroupDefs := c.Groups
c.Groups = make([]GroupDef, 0, len(existingGroupDefs))
for _, group := range existingGroupDefs {
if group.Name != name {
c.Groups = append(c.Groups, group)
}
}
return nil
}
// AddGroups adds a slice of groups to the Config
func (c *Config)
|
(groups []services.ServiceGroupConfig) error {
log.Printf("Adding %d groups.\n", len(groups))
for _, group := range groups {
grp := GroupDef{
Name: group.Name,
Aliases: group.Aliases,
Description: group.Description,
Children: []string{},
Env: group.Env,
}
for _, cg := range group.Groups {
if cg != nil {
grp.Children = append(grp.Children, cg.Name)
}
}
for _, cs := range group.Services {
if cs != nil {
grp.Children = append(grp.Children, cs.Name)
}
}
c.Groups = append(c.Groups, grp)
}
return nil
}
func (c *Config) loadImports() error {
log.Printf("Loading imports\n")
for _, i := range c.Imports {
var cPath string
if filepath.IsAbs(i) {
cPath = i
} else {
cPath = filepath.Join(c.workingDir, i)
}
log.Printf("Loading: %v\n", cPath)
r, err := os.Open(cPath)
if err != nil {
return errors.WithStack(err)
}
cfg, err := loadConfigContents(r, filepath.Dir(cPath))
if err != nil {
return errors.WithMessage(err, i)
}
err = c.importConfig(cfg)
if err != nil {
return errors.WithStack(err)
}
}
return nil
}
func (c *Config) importConfig(second Config) error {
for _, service := range append(second.Services, second.ImportedServices...) {
c.ImportedServices = append(c.ImportedServices, service)
}
for _, group := range append(second.Groups, second.ImportedGroups...) {
c.ImportedGroups = append(c.ImportedGroups, group)
}
return nil
}
func (c *Config) combinePath(path string) *string {
if filepath.IsAbs(path) || strings.HasPrefix(path, "$") {
return &path
}
fullPath := filepath.Join(c.workingDir, path)
return &fullPath
}
func addToMap(m map[string]struct{}, values ...string) {
for _, v := range values {
m[v] = struct{}{}
}
}
func intersect(m map[string]struct{}, values ...string) []string {
var out []string
for _, v := range values {
if _, ok := m[v]; ok {
out = append(out, v)
}
}
sort.Strings(out)
return out
}
func (c *Config) initMaps() error {
var err error
var svcs = make(map[string]*services.ServiceConfig)
var servicesSkipped = make(map[string]struct{})
var namesInUse = make(map[string]struct{})
for _, s := range append(c.Services, c.ImportedServices...) {
sc := s
sc.Env = append(sc.Env, c.Env...)
sc.ConfigFile, err = filepath.Abs(c.FilePath)
if err != nil {
return errors.WithStack(err)
}
if sc.MatchesPlatform() {
if i := intersect(namesInUse, append(sc.Aliases, sc.Name)...); len(i) > 0 {
return fmt.Errorf("Duplicate name or alias: %v", strings.Join
|
AddGroups
|
identifier_name
|
config.go
|
{
return errors.WithStack(err)
}
_, err = writer.Write(content)
return errors.WithStack(err)
}
// NewConfig creates a Config from slices of services and groups
func NewConfig(newServices []services.ServiceConfig, newGroups []services.ServiceGroupConfig) Config {
log.Printf("Creating new config with %d services and %d groups.\n", len(newServices), len(newGroups))
// Find Env settings common to all services
var allEnvSlices [][]string
for _, s := range newServices {
allEnvSlices = append(allEnvSlices, s.Env)
}
env := stringSliceIntersect(allEnvSlices)
// Remove common settings from services
var svcs []services.ServiceConfig
for _, s := range newServices {
s.Env = stringSliceRemoveCommon(env, s.Env)
svcs = append(svcs, s)
}
cfg := Config{
Env: env,
Services: svcs,
Groups: []GroupDef{},
}
cfg.AddGroups(newGroups)
log.Printf("Config created: %v", cfg)
return cfg
}
// EmptyConfig creates a Config with no services or groups
func EmptyConfig(workingDir string) Config {
log.Printf("Creating empty config\n")
cfg := Config{
workingDir: workingDir,
}
cfg.ServiceMap = make(map[string]*services.ServiceConfig)
cfg.GroupMap = make(map[string]*services.ServiceGroupConfig)
return cfg
}
// NormalizeServicePaths will modify the Paths for each of the provided services
// to be relative to the working directory of this config file
func (c *Config) NormalizeServicePaths(searchPath string, newServices []*services.ServiceConfig) ([]*services.ServiceConfig, error) {
log.Printf("Normalizing paths for %d services.\n", len(newServices))
var outServices []*services.ServiceConfig
for _, s := range newServices {
curService := *s
fullPath := filepath.Join(searchPath, *curService.Path)
relPath, err := filepath.Rel(c.workingDir, fullPath)
if err != nil {
return outServices, errors.WithStack(err)
}
curService.Path = &relPath
outServices = append(outServices, &curService)
}
return outServices, nil
}
// AppendServices adds services to an existing config without replacing existing services
func (c *Config) AppendServices(newServices []*services.ServiceConfig) error {
log.Printf("Appending %d services.\n", len(newServices))
if c.ServiceMap == nil {
c.ServiceMap = make(map[string]*services.ServiceConfig)
}
for _, s := range newServices {
if _, found := c.ServiceMap[s.Name]; !found {
c.ServiceMap[s.Name] = s
c.Services = append(c.Services, *s)
}
}
return nil
}
// AppendGroups adds groups to an existing config without replacing existing groups
func (c *Config) AppendGroups(groups []*services.ServiceGroupConfig) error {
var groupsDereferenced []services.ServiceGroupConfig
for _, group := range groups {
groupsDereferenced = append(groupsDereferenced, *group)
}
return errors.WithStack(c.AddGroups(groupsDereferenced))
}
func (c *Config) RemoveGroup(name string) error {
if _, ok := c.GroupMap[name]; !ok {
return errors.New("Group not found")
}
delete(c.GroupMap, name)
existingGroupDefs := c.Groups
c.Groups = make([]GroupDef, 0, len(existingGroupDefs))
for _, group := range existingGroupDefs {
if group.Name != name {
c.Groups = append(c.Groups, group)
}
}
return nil
}
// AddGroups adds a slice of groups to the Config
func (c *Config) AddGroups(groups []services.ServiceGroupConfig) error {
log.Printf("Adding %d groups.\n", len(groups))
for _, group := range groups {
grp := GroupDef{
Name: group.Name,
Aliases: group.Aliases,
Description: group.Description,
Children: []string{},
Env: group.Env,
}
for _, cg := range group.Groups {
if cg != nil {
grp.Children = append(grp.Children, cg.Name)
}
}
for _, cs := range group.Services {
if cs != nil {
grp.Children = append(grp.Children, cs.Name)
}
}
c.Groups = append(c.Groups, grp)
}
return nil
}
func (c *Config) loadImports() error {
log.Printf("Loading imports\n")
for _, i := range c.Imports {
var cPath string
if filepath.IsAbs(i) {
cPath = i
} else {
cPath = filepath.Join(c.workingDir, i)
}
log.Printf("Loading: %v\n", cPath)
r, err := os.Open(cPath)
if err != nil {
return errors.WithStack(err)
}
cfg, err := loadConfigContents(r, filepath.Dir(cPath))
if err != nil {
return errors.WithMessage(err, i)
}
err = c.importConfig(cfg)
if err != nil {
return errors.WithStack(err)
}
}
return nil
}
func (c *Config) importConfig(second Config) error {
for _, service := range append(second.Services, second.ImportedServices...) {
c.ImportedServices = append(c.ImportedServices, service)
}
for _, group := range append(second.Groups, second.ImportedGroups...) {
c.ImportedGroups = append(c.ImportedGroups, group)
}
return nil
}
func (c *Config) combinePath(path string) *string {
if filepath.IsAbs(path) || strings.HasPrefix(path, "$") {
return &path
}
fullPath := filepath.Join(c.workingDir, path)
return &fullPath
}
func addToMap(m map[string]struct{}, values ...string) {
for _, v := range values {
m[v] = struct{}{}
}
}
func intersect(m map[string]struct{}, values ...string) []string {
var out []string
for _, v := range values {
if _, ok := m[v]; ok {
out = append(out, v)
}
}
sort.Strings(out)
return out
}
func (c *Config) initMaps() error {
var err error
var svcs = make(map[string]*services.ServiceConfig)
var servicesSkipped = make(map[string]struct{})
var namesInUse = make(map[string]struct{})
for _, s := range append(c.Services, c.ImportedServices...) {
sc := s
sc.Env = append(sc.Env, c.Env...)
sc.ConfigFile, err = filepath.Abs(c.FilePath)
if err != nil {
return errors.WithStack(err)
}
if sc.MatchesPlatform() {
if i := intersect(namesInUse, append(sc.Aliases, sc.Name)...); len(i) > 0 {
return fmt.Errorf("Duplicate name or alias: %v", strings.Join(i, ", "))
}
svcs[sc.Name] = &sc
addToMap(namesInUse, append(sc.Aliases, sc.Name)...)
} else {
servicesSkipped[sc.Name] = struct{}{}
}
}
var groups = make(map[string]*services.ServiceGroupConfig)
// First pass: Services
var orphanNames = make(map[string]struct{})
for _, g := range append(c.Groups, c.ImportedGroups...) {
var childServices []*services.ServiceConfig
for _, name := range g.Children {
if s, ok := svcs[name]; ok {
if s.Path != nil {
s.Path = c.combinePath(*s.Path)
}
childServices = append(childServices, s)
} else if _, skipped := servicesSkipped[name]; !skipped {
orphanNames[name] = struct{}{}
}
}
if i := intersect(namesInUse, append(g.Aliases, g.Name)...); len(i) > 0 {
return fmt.Errorf("Duplicate name or alias: %v", strings.Join(i, ", "))
}
groups[g.Name] = &services.ServiceGroupConfig{
Name: g.Name,
Aliases: g.Aliases,
Description: g.Description,
Services: childServices,
Groups: []*services.ServiceGroupConfig{},
Env: g.Env,
ChildOrder: g.Children,
}
addToMap(namesInUse, append(g.Aliases, g.Name)...)
}
// Second pass: Groups
for _, g := range append(c.Groups, c.ImportedGroups...) {
childGroups := []*services.ServiceGroupConfig{}
for _, name := range g.Children {
if gr, ok := groups[name]; ok {
delete(orphanNames, name)
childGroups = append(childGroups, gr)
}
if hasChildCycle(groups[g.Name], childGroups) {
return errors.New("group cycle: " + g.Name)
}
}
groups[g.Name].Groups = childGroups
}
if len(orphanNames) > 0
|
{
var keys []string
for k := range orphanNames {
keys = append(keys, k)
}
return errors.New("A service or group could not be found for the following names: " + strings.Join(keys, ", "))
}
|
conditional_block
|
|
scriptAppoint.js
|
;
case 9:
m = "10";
break;
case 10:
m = "11";
break;
case 11:
m = "12";
break;
}
fechaCita = a + "/" + m + "/" + d; //formato año/mes/dia hecho por evelyn
document.getElementById('fechaId').value = fechaCita;
//document.getElementById('lider').value = fechaCita;
return false;
}else {
window.alert("Por favor, verifica sí ya escogistes fecha de cita y horario");
return false;
}
return true;
}
// Mostrar todos los eventos de la fecha seleccionada en vistas de tarjeta
function show_events(events, month, day) {
// limpiar de datos los dos container
$(".events-container").empty(); /* */
// $(".events-container").show(250);
console.log(event_data["events"]);
// var date = event.data.date;
// Si no hay eventos para esta fecha, notifique al usuario
if (events.length === 0) {
var event_card = $("<div class='event-card'></div>");
var event_name = $("<div class='event-name'>There are no events planned for " + month + " " + day + ".</div>");
$(event_card).css({ "border-left": "10px solid #FF1744" });
$(event_card).append(event_name);
$(".events-container").append(event_card);
}
else {
// Go through and add each event as a card to the events container
for (var i = 0; i < events.length; i++) {
var event_card = $("<div class='event-card'></div>");
var event_name = $("<div class='event-name'>" + events[i]["occasion"] + ":</div>");
var event_count = $("<div class='event-count'>" + events[i]["invited_count"] + " Invited</div>");
if (events[i]["cancelled"] === true) {
$(event_card).css({
"border-left": "10px solid #FF1744"
});
event_count = $("<div class='event-cancelled'>Cancelled</div>");
}
$(event_card).append(event_name).append(event_count);
$(".events-container").append(event_card);
}
}
}
// Comprueba si una fecha específica tiene algún evento
function check_events(day, month, year) {
var events = [];
for (var i = 0; i < event_data["events"].length; i++) {
var event = event_data["events"][i];
if (event["day"] === day &&
event["month"] === month &&
event["year"] === year) {
events.push(event);
}
}
return events;
}
// // Datos dados para eventos en formato JSON
var event_data = {
"events": [
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Test Event",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 11
}
]
};
const months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"
];
// funcion para obtner la hora
function obtenerHor(id){
switch(id){
case "9":
document.getElementById('horaId').value = '09-10'; /* asignando un valor al id */
break;
case "10":
document.getElementById('horaId').value = '10-11';
ban2 = 1;
break;
case "11":
document.getElementById('horaId').value = '11-12';
ban2 = 1;
break;
case "12":
document.getElementById('horaId').value = "12-13";
ban2 = 1;
break
case "13":
document.getElementById('horaId').value = "13-14";
ban2 = 1;
break;
case "16":
document.getElementById('horaId').value = "16-17";
ban2 = 1;
break;
case "17":
document.getElementById('horaId').value = "17-18";
ban2 = 1;
break;
case "18":
document.getElementById('horaId').value = "18-19";
ban2 = 1;
break;
}
}
/* validacion de los campos del formmulario */
function validacionForm() {
var reason = "";
var nom = document.getElementById("name");
var mot = document.getElementById("cita");
var tel = document.getElementById("numer");
reason += validateName(nom);
reason += validateCita(mot);
reason += validatePhone(tel);
if (reason != "") {
window.alert("Algunos de los campos necesita correción\n" + reason);
return false;
}
return true;
}
/* validacion de la caja de nombre */
function validateName(nombre) {
var error = "";
// var illegalChars = /\W/; // permite letras, números y guiones bajos
if (nombre.value == "" || nombre.value == null || (/^\s+$/.test(nombre.value))) {
nombre.style.background = 'red';
error="La caja para nombre no contiene nada...\n";
nombre.focus();
}else if ((nombre.length < 3) || (nombre.length > 30)) {
nombre.style.background = 'red';
error = "El nombre tiene una longitud incorrecta...\n";
nombre.focus();
}else {
nombre.style.background = 'White';
}
// } else if (illegalChars.test(nombre.value)) {
// nombre.style.background = 'red';
// error = "El nombre ingresado contiene caracteres ilegales.\n";
// nombre.focus();
// }
return error;
}
function validateCita(cita){
var error = "";
if (cita.value == 0 || cita.length < 5 || cita.length > 30 ) {
cita.style.background = 'reed';
err
|
or = "Verifique el campo cita, antes de seguir\n"
} else {
cita.style.background = 'White';
|
conditional_block
|
|
scriptAppoint.js
|
0);
var date = event.data.date; // obtiene la fecha del ultimo dia del mes anterior
var mesAc = event.data.mes;// obtiene el mes actual, regresa un num
var new_month = $(".month").index(this); // regresa el nuemero del mes seleccionado
var ahioSel = date.getFullYear();
var ahioAc= event.data.anio;
if (mesAc==11 && ahioSel!==ahioAc){
if(new_month==0 || new_month==1){
$(".active-month").removeClass("active-month"); //remueve las clases
$(this).addClass("active-month"); // agrega una clase
date.setMonth(new_month); // se le asigna al dato al mes nuevo
init_calendar(date); //inicia el calendario con la fecha propor
}else{
window.alert("Mes no disponible");
}
} else if (new_month >= mesAc && new_month<= (mesAc + 2) && ahioSel==ahioAc) {
$(".active-month").removeClass("active-month"); //remueve las clases
$(this).addClass("active-month"); // agrega una clase
date.setMonth(new_month); // se le asigna al dato al mes nuevo
init_calendar(date); //inicia el calendario con la fecha propor
}
else {
window.alert("Mes no disponible");
}
}
//Controlador de eventos para cuando se hace clic en el botón derecho del año
function next_year(event, anio) {
$("#dialog").hide(250);
$(".events-container").hide(250);
var date = event.data.date; //obtiene la fecha del ultimo día del mes anterior
new_year = date.getFullYear() + 1; // devuelve el año actaul, y se le agrega 1 para el proximo año
if ((event.data.anio + 1) == new_year) {
$(".year").html(new_year); // se le agrega e texto a la clase
date.setFullYear(new_year); // le asigna al date, el año proximo con un mes antes
init_calendar(date);// el calendario se inicia con el ultimo dia del mes anterio
}
else{
window.alert("Año no disponible");
}
}
// Controlador de eventos para cuando se hace clic en el botón izquierdo del año
function prev_year(event, anio) {
$("#dialog").hide(250);
$(".events-container").hide(250);
var date = event.data.date; // obtiene la fecha del ultimo dia del mes anterior
new_year = date.getFullYear() - 1;// devuelve el año actaul, y se le le resta -1 para el año anterior
if (event.data.anio == new_year)
{
$("year").html(new_year);// se le agrega e texto a la clase
date.setFullYear(new_year);// le asigna al date, el año anterior, con fecha del ultimo dia del mes anterior a la que estamos
init_calendar(date);//inicia el calendario
}
}
// Controlador de eventos para hacer clic en el botón del nuevo evento
function new_event(event) {
if (ban==0){
window.alert("Antes de, escoge una fecha para tu cita.");
return false;
}
/*if (ban2 == 0) {
window.alert("Antes de, escoge una hora para tu cita.");
return false;
}*/
if(ban==1){
var date = event.data.date;
var a = date.getFullYear();
var m = date.getMonth();
$(".horarios-container").hide(250);
$(".events-container").hide(250);
$(".dialog").show(250); // muestra el contenedor para requisitar la cita
switch (m) {
case 0:
m = "01";
break;
case 1:
m = "02";
break;
case 2:
m = "03";
break;
case 3:
m = "04";
break;
case 4:
m = "05";
break;
case 5:
m = "06";
break;
case 6:
m = "07";
break;
case 7:
m = "08";
break;
case 8:
m = "09";
break;
case 9:
m = "10";
break;
case 10:
m = "11";
break;
case 11:
m = "12";
break;
}
fechaCita = a + "/" + m + "/" + d; //formato año/mes/dia hecho por evelyn
document.getElementById('fechaId').value = fechaCita;
//document.getElementById('lider').value = fechaCita;
return false;
}else {
window.alert("Por favor, verifica sí ya escogistes fecha de cita y horario");
return false;
}
return true;
}
// Mostrar todos los eventos de la fecha seleccionada en vistas de tarjeta
function show_events(events, month, day) {
// limpiar de datos los dos container
$(".events-container").empty(); /* */
// $(".events-container").show(250);
console.log(event_data["events"]);
// var date = event.data.date;
// Si no hay eventos para esta fecha, notifique al usuario
if (events.length === 0) {
var event_card = $("<div class='event-card'></div>");
var event_name = $("<div class='event-name'>There are no events planned for " + month + " " + day + ".</div>");
$(event_card).css({ "border-left": "10px solid #FF1744" });
$(event_card).append(event_name);
$(".events-container").append(event_card);
}
else {
// Go through and add each event as a card to the events container
for (var i = 0; i < events.length; i++) {
var event_card = $("<div class='event-card'></div>");
var event_name = $("<div class='event-name'>" + events[i]["occasion"] + ":</div>");
var event_count = $("<div class='event-count'>" + events[i]["invited_count"] + " Invited</div>");
if (events[i]["cancelled"] === true) {
$(event_card).css({
"border-left": "10px solid #FF1744"
});
event_count = $("<div class='event-cancelled'>Cancelled</div>");
}
$(event_card).append(event_name).append(event_count);
$(".events-container").append(event_card);
}
}
}
// Comprueba si una fecha específica tiene algún evento
function check_events(day, month, year) {
var events = [];
for (var i = 0; i < event_data["events"].length; i++) {
var event = event_data["events"][i];
if (event["day"] === day &&
event["month"] === month &&
event["year"] === year) {
events.push(event);
}
}
return events;
}
// // Datos dados para eventos en formato JSON
var event_data = {
"events": [
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
|
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
|
random_line_split
|
|
scriptAppoint.js
|
]["occasion"] + ":</div>");
var event_count = $("<div class='event-count'>" + events[i]["invited_count"] + " Invited</div>");
if (events[i]["cancelled"] === true) {
$(event_card).css({
"border-left": "10px solid #FF1744"
});
event_count = $("<div class='event-cancelled'>Cancelled</div>");
}
$(event_card).append(event_name).append(event_count);
$(".events-container").append(event_card);
}
}
}
// Comprueba si una fecha específica tiene algún evento
function check_events(day, month, year) {
var events = [];
for (var i = 0; i < event_data["events"].length; i++) {
var event = event_data["events"][i];
if (event["day"] === day &&
event["month"] === month &&
event["year"] === year) {
events.push(event);
}
}
return events;
}
// // Datos dados para eventos en formato JSON
var event_data = {
"events": [
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Test Event",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 11
}
]
};
const months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"
];
// funcion para obtner la hora
function obtenerHor(id){
switch(id){
case "9":
document.getElementById('horaId').value = '09-10'; /* asignando un valor al id */
break;
case "10":
document.getElementById('horaId').value = '10-11';
ban2 = 1;
break;
case "11":
document.getElementById('horaId').value = '11-12';
ban2 = 1;
break;
case "12":
document.getElementById('horaId').value = "12-13";
ban2 = 1;
break
case "13":
document.getElementById('horaId').value = "13-14";
ban2 = 1;
break;
case "16":
document.getElementById('horaId').value = "16-17";
ban2 = 1;
break;
case "17":
document.getElementById('horaId').value = "17-18";
ban2 = 1;
break;
case "18":
document.getElementById('horaId').value = "18-19";
ban2 = 1;
break;
}
}
/* validacion de los campos del formmulario */
function validacionForm() {
var reason = "";
var nom = document.getElementById("name");
var mot = document.getElementById("cita");
var tel = document.getElementById("numer");
reason += validateName(nom);
reason += validateCita(mot);
reason += validatePhone(tel);
if (reason != "") {
window.alert("Algunos de los campos necesita correción\n" + reason);
return false;
}
return true;
}
/* validacion de la caja de nombre */
function validateName(nombre) {
var error = "";
// var illegalChars = /\W/; // permite letras, números y guiones bajos
if (nombre.value == "" || nombre.value == null || (/^\s+$/.test(nombre.value))) {
nombre.style.background = 'red';
error="La caja para nombre no contiene nada...\n";
nombre.focus();
}else if ((nombre.length < 3) || (nombre.length > 30)) {
nombre.style.background = 'red';
error = "El nombre tiene una longitud incorrecta...\n";
nombre.focus();
}else {
nombre.style.background = 'White';
}
// } else if (illegalChars.test(nombre.value)) {
// nombre.style.background = 'red';
// error = "El nombre ingresado contiene caracteres ilegales.\n";
// nombre.focus();
// }
return error;
}
function validateCita(cita){
var error = "";
if (cita.value == 0 || cita.length < 5 || cita.length > 30 ) {
cita.style.background = 'reed';
error = "Verifique el campo cita, antes de seguir\n"
} else {
cita.style.background = 'White';
}
return error;
}
function validatePhone(tel) {
var error = "";
var stripped = tel.value.replace(/[\(\)\.\-\ ]/g, '');
if (tel.value == "" || tel.value==null) {
error = "No ingresó un número de teléfono..\n";
tel.style.background = 'red';
} else if (isNaN(parseInt(stripped))) {
error = "El número de teléfono contiene caracteres ilegales..\n";
tel.style.background = 'red';
} else if (!(stripped.length == 10)) {
error = "El número de teléfono tiene la longitud incorrecta. Asegúrese de incluir un código de área.\n";
tel.style.background = 'red';
}
return error;
}
// Obtener referencia a botones
// Recuerda: el punto . indica clases
const botones = document.querySelectorAll(".botonC");
// Definir función y evitar definirla de manera anónima
const cuandoSeHaceClick = function (evento) {
// Recuerda, this es el elemento
// window.alert("El texto que tiene es: ", this.innerText);
ban2=1;
}
// botones es un arreglo así que lo recorremos
botones.forEach(boton => {
//Agregar listener
boton.addEventListener("click", cuandoSeHaceClick);
});
function botonCancelar(){
$("#dialog").hide(250);
$(".horarios-container").s
|
how(250);
//$(".horariosss").show(250);
//$(".horariosss").show(250);
ban=0;
ban2=0;
document.getElementById('fechaId').innerHTML = "";
document.getElementById('horaId').innerHTML = "";
document.getElementById('name').innerHTML = "";
document.getElementById('cita').innerHTML = "";
document.getElementById('numer').innerHTML = "";
}
|
identifier_body
|
|
scriptAppoint.js
|
para tu cita.");
return false;
}
/*if (ban2 == 0) {
window.alert("Antes de, escoge una hora para tu cita.");
return false;
}*/
if(ban==1){
var date = event.data.date;
var a = date.getFullYear();
var m = date.getMonth();
$(".horarios-container").hide(250);
$(".events-container").hide(250);
$(".dialog").show(250); // muestra el contenedor para requisitar la cita
switch (m) {
case 0:
m = "01";
break;
case 1:
m = "02";
break;
case 2:
m = "03";
break;
case 3:
m = "04";
break;
case 4:
m = "05";
break;
case 5:
m = "06";
break;
case 6:
m = "07";
break;
case 7:
m = "08";
break;
case 8:
m = "09";
break;
case 9:
m = "10";
break;
case 10:
m = "11";
break;
case 11:
m = "12";
break;
}
fechaCita = a + "/" + m + "/" + d; //formato año/mes/dia hecho por evelyn
document.getElementById('fechaId').value = fechaCita;
//document.getElementById('lider').value = fechaCita;
return false;
}else {
window.alert("Por favor, verifica sí ya escogistes fecha de cita y horario");
return false;
}
return true;
}
// Mostrar todos los eventos de la fecha seleccionada en vistas de tarjeta
function show_events(events, month, day) {
// limpiar de datos los dos container
$(".events-container").empty(); /* */
// $(".events-container").show(250);
console.log(event_data["events"]);
// var date = event.data.date;
// Si no hay eventos para esta fecha, notifique al usuario
if (events.length === 0) {
var event_card = $("<div class='event-card'></div>");
var event_name = $("<div class='event-name'>There are no events planned for " + month + " " + day + ".</div>");
$(event_card).css({ "border-left": "10px solid #FF1744" });
$(event_card).append(event_name);
$(".events-container").append(event_card);
}
else {
// Go through and add each event as a card to the events container
for (var i = 0; i < events.length; i++) {
var event_card = $("<div class='event-card'></div>");
var event_name = $("<div class='event-name'>" + events[i]["occasion"] + ":</div>");
var event_count = $("<div class='event-count'>" + events[i]["invited_count"] + " Invited</div>");
if (events[i]["cancelled"] === true) {
$(event_card).css({
"border-left": "10px solid #FF1744"
});
event_count = $("<div class='event-cancelled'>Cancelled</div>");
}
$(event_card).append(event_name).append(event_count);
$(".events-container").append(event_card);
}
}
}
// Comprueba si una fecha específica tiene algún evento
function check_events(day, month, year) {
var events = [];
for (var i = 0; i < event_data["events"].length; i++) {
var event = event_data["events"][i];
if (event["day"] === day &&
event["month"] === month &&
event["year"] === year) {
events.push(event);
}
}
return events;
}
// // Datos dados para eventos en formato JSON
var event_data = {
"events": [
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10,
"cancelled": true
},
{
"occasion": " Repeated Test Event ",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 10
},
{
"occasion": " Test Event",
"invited_count": 120,
"year": 2017,
"month": 5,
"day": 11
}
]
};
const months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"
];
// funcion para obtner la hora
function obtenerHor(id){
switch(id){
case "9":
document.getElementById('horaId').value = '09-10'; /* asignando un valor al id */
break;
case "10":
document.getElementById('horaId').value = '10-11';
ban2 = 1;
break;
case "11":
document.getElementById('horaId').value = '11-12';
ban2 = 1;
break;
case "12":
document.getElementById('horaId').value = "12-13";
ban2 = 1;
break
case "13":
document.getElementById('horaId').value = "13-14";
ban2 = 1;
break;
case "16":
document.getElementById('horaId').value = "16-17";
ban2 = 1;
break;
case "17":
document.getElementById('horaId').value = "17-18";
ban2 = 1;
break;
case "18":
document.getElementById('horaId').value = "18-19";
ban2 = 1;
break;
}
}
/* validacion de los campos del formmulario */
function validacionForm() {
var reason = "";
var nom = document.getElementById("name");
var mot = document.getElementById("cita");
var tel = document.getElementById("numer");
reason += validateName(nom);
reason += validateCita(mot);
reason += validatePhone(tel);
if (reason != "") {
window.alert("Algunos de los campos necesita correción\n" + reason);
return false;
}
return true;
}
/* validacion de la caja de nombre */
function validateName(nombre) {
var error = ""
|
;
// var i
|
identifier_name
|
|
example_all.py
|
, 1.2, (100, 1)), axis=0)
train_y = objectiveFunction(train_x)
train_data = np.hstack([train_x, train_y])
test_x = np.linspace(-0.5, 1.5, 1000).reshape(-1, 1)
# test_x = np.sort(np.random.uniform(-1, 1, (100, 1)), axis=0)
test_y = objectiveFunction(test_x)
test_data = np.hstack([test_x, test_y])
train_x = train_data[:, :-1]
train_y = train_data[:, [-1]]
test_x = test_data[:, :-1]
test_y = test_data[:, [-1]]
N, D = train_x.shape
print("Dataset size: {} * {}".format(N, D))
if scoreMetric == "RMSE":
Nv = int(0.2 * N)
N -= Nv
val_x = train_x[-Nv:, :]
val_y = train_y[-Nv:].reshape(-1, 1)
train_x = train_x[:-Nv, :]
train_y = train_y[:-Nv].reshape(-1, 1)
vizData = False
if vizData:
plt.figure()
plt.plot(train_x, train_y, 'b-', label="train set")
if scoreMetric == "RMSE":
plt.plot(val_x, val_y, 'g-', label="validation set")
plt.plot(test_x, test_y, 'r-', label="test set")
plt.xlim(min(np.min(train_x), np.min(test_x)) - .2,
max(np.max(train_x), np.max(test_x)) + .2)
plt.ylim(min(np.min(train_y), np.min(test_y)) - .2,
max(np.max(train_y), np.max(test_y)) + .2)
plt.title("Data set")
plt.legend(loc=2)
plt.show()
exit()
"""
Quantile parametrisation
"""
if quantileParametrisation == parametrisations.BoundedQPoints:
qp = quantileParametrisation(6, p1=(0.03, -100), p2=(0.97, 100))
elif quantileParametrisation == parametrisations.StairCase:
qp = quantileParametrisation(9, p1=(0.03, -150), p2=(0.97, 150))
else:
qp = quantileParametrisation()
genParams = qp.gen_params
interpolator = qp.interpolator
paramLow = qp.paramLow
paramHigh = qp.paramHigh
scaleParams = qp.scale_params
if datasetName == "co2":
if quantileParametrisation == parametrisations.PeriodicSimple:
paramHigh[0] = 2.3
paramLow[0] = 2
paramHigh[1] = 0.2
paramLow[1] = 0.01
elif datasetName == "airline":
if quantileParametrisation == parametrisations.PeriodicSimple:
paramLow[0] = 2.3
paramHigh[0] = 2.8
paramLow[1] = 0.001
elif datasetName == "pores":
pass
# paramLow[0] = 1.0
# paramHigh[0] = 2.8
# paramLow[1] = 0.01
# paramHigh[1] = 0.45
elif datasetName == "rubber":
pass
# paramLow[0] = 1.0
# paramHigh[0] = 2.8
# paramLow[1] = 0.01
# paramHigh[1] = 0.25
elif datasetName == "tread":
pass
# paramLow[0] = 1.0
# paramHigh[0] = 2.5
# paramLow[1] = 0.001
# paramHigh[1] = 0.01
if quantileParametrisation == parametrisations.InterpSingleSpline:
paramHigh[1] = 6
paramHigh[0] = 2.3
paramLow[0] = 1.5
"""
Kernel composition
"""
# composition = ["linear", "+", "linear_no_bias", "*", "bbq"]
# composition = ["linear", "+", "bbq"]
# composition = ["linear", "*", "linear_no_bias", "+", "bbq"]
# composition = ["linear", "+", "linear_no_bias", "*", "bbq"]
composition = ["bbq"]
if datasetName == "co2":
# composition = ["linear", "*", "linear_no_bias", "+", "bbq"]
composition = ["linear_no_bias", "+", "bbq"]
elif datasetName == "airline":
composition = ["linear", "+", "linear", "*", "bbq"]
# composition = ["linear", "*", "linear_no_bias", "+",
# "linear", "*", "bbq"]
# composition = ["linear", "*", "linear_no_bias", "+",
# "linear", "*", "linear_no_bias", "*", "bbq", "+", "bbq"]
if basicRBF:
# composition = ["rbf" if e == "bbq" else e for e in composition]
composition = ["rbf"]
qp.paramLow = np.array([-3])
qp.paramHigh = np.array([0])
qp.logScaleParams = np.array([True])
paramLow = qp.paramLow
paramHigh = qp.paramHigh
"""
Search/optimisation for best quantile
"""
if useARDkernel:
paramLow = np.array(D * list(paramLow))
paramHigh = np.array(D * list(paramHigh))
qp.logScaleParams = np.array(D * list(qp.logScaleParams))
if learnBeta:
paramLow = np.array([-3] + list(paramLow))
paramHigh = np.array([3] + list(paramHigh))
print("parameter space high: {}".format(paramHigh))
print("parameter space low: {}".format(paramLow))
score, allParams, bo = None, None, None
if searchStrategy == "Gridsearch":
assert (len(paramLow) == 2 and "Gridsearch only designed for 2 params")
X, Y = np.meshgrid(np.linspace(paramLow[0], paramHigh[0], gridRes),
np.linspace(paramLow[1], paramHigh[1], gridRes))
allParams = np.hstack([X.reshape(-1, 1), Y.reshape(-1, 1)])
score = np.zeros((gridRes ** 2,))
for i in tqdm(range(allParams.shape[0])):
if learnBeta:
blrBeta = 10 ** (allParams[i, 0])
curParams = allParams[i, 1:]
else:
curParams = allParams[i, :]
scaledParams = scaleParams(curParams)
score[i] = -train_model(scaledParams, blrBeta)
elif searchStrategy == "BO":
search_int = np.vstack([np.atleast_2d(paramLow),
np.atleast_2d(paramHigh)]).T
bo = None # BO.BO(search_int, acq_fun=BO.UCB(boKappa), opt_maxeval=20,
allParams = np.zeros((nBOIter, len(paramLow)))
score = np.zeros((nBOIter,))
for i in tqdm(range(nBOIter)):
allParams[i, :] = bo.next_sample()
if learnBeta:
blrBeta = 10 ** (allParams[i, 0])
curParams = allParams[i, 1:]
else:
curParams = allParams[i, :]
scaledParams = scaleParams(curParams)
score[i] = -train_model(scaledParams, blrBeta)
bo.update(allParams[i, :].reshape(1, -1),
np.array(score[i]).reshape(-1, 1))
elif searchStrategy == "NLopt":
allParams = np.zeros((nlOptIter, len(paramLow)))
score = np.zeros((nlOptIter,))
pbar = tqdm(total=nlOptIter)
i = 0
# Nlopt params
opt = nlopt.opt(nlOptAlgo, len(paramLow))
opt.set_lower_bounds(np.array(paramLow).reshape(-1))
opt.set_upper_bounds(np.array(paramHigh).reshape(-1))
opt.set_maxeval(nlOptIter)
def _fun_maximize(_x, grad):
|
global i
if i == nlOptIter:
print("Warning: maximum number of iterations reached.")
return float(np.min(score))
allParams[i, :] = _x
if learnBeta:
global blrBeta
blrBeta = 10 ** (allParams[i, 0])
curParams = allParams[i, 1:]
else:
curParams = allParams[i, :]
scaledParams = scaleParams(curParams)
curScore = float(-train_model(scaledParams, blrBeta))
# Keep track of previous tries
score[i] = curScore
i += 1
pbar.update(1)
|
identifier_body
|
|
example_all.py
|
= datasets.textures_2D(texture_name=datasetName)
else:
if datasetName == "cosine":
objectiveFunction = toy_functions.cosine
elif datasetName == "harmonics":
objectiveFunction = toy_functions.harmonics
elif datasetName == "pattern":
objectiveFunction = toy_functions.pattern
elif datasetName == "heaviside":
objectiveFunction = toy_functions.heaviside
elif datasetName == "quadraticCos":
objectiveFunction = toy_functions.quadratic_cos
elif datasetName == "steps":
objectiveFunction = toy_functions.steps
else:
raise RuntimeError("Objective function was not defined")
train_x = np.sort(np.random.uniform(-0.3, 1.2, (100, 1)), axis=0)
train_y = objectiveFunction(train_x)
train_data = np.hstack([train_x, train_y])
test_x = np.linspace(-0.5, 1.5, 1000).reshape(-1, 1)
# test_x = np.sort(np.random.uniform(-1, 1, (100, 1)), axis=0)
test_y = objectiveFunction(test_x)
test_data = np.hstack([test_x, test_y])
train_x = train_data[:, :-1]
train_y = train_data[:, [-1]]
test_x = test_data[:, :-1]
test_y = test_data[:, [-1]]
N, D = train_x.shape
print("Dataset size: {} * {}".format(N, D))
if scoreMetric == "RMSE":
Nv = int(0.2 * N)
N -= Nv
val_x = train_x[-Nv:, :]
val_y = train_y[-Nv:].reshape(-1, 1)
train_x = train_x[:-Nv, :]
train_y = train_y[:-Nv].reshape(-1, 1)
vizData = False
if vizData:
plt.figure()
plt.plot(train_x, train_y, 'b-', label="train set")
if scoreMetric == "RMSE":
plt.plot(val_x, val_y, 'g-', label="validation set")
plt.plot(test_x, test_y, 'r-', label="test set")
plt.xlim(min(np.min(train_x), np.min(test_x)) - .2,
max(np.max(train_x), np.max(test_x)) + .2)
plt.ylim(min(np.min(train_y), np.min(test_y)) - .2,
max(np.max(train_y), np.max(test_y)) + .2)
plt.title("Data set")
plt.legend(loc=2)
plt.show()
exit()
"""
Quantile parametrisation
"""
if quantileParametrisation == parametrisations.BoundedQPoints:
qp = quantileParametrisation(6, p1=(0.03, -100), p2=(0.97, 100))
elif quantileParametrisation == parametrisations.StairCase:
qp = quantileParametrisation(9, p1=(0.03, -150), p2=(0.97, 150))
else:
qp = quantileParametrisation()
genParams = qp.gen_params
interpolator = qp.interpolator
paramLow = qp.paramLow
paramHigh = qp.paramHigh
scaleParams = qp.scale_params
if datasetName == "co2":
if quantileParametrisation == parametrisations.PeriodicSimple:
paramHigh[0] = 2.3
paramLow[0] = 2
paramHigh[1] = 0.2
paramLow[1] = 0.01
elif datasetName == "airline":
if quantileParametrisation == parametrisations.PeriodicSimple:
paramLow[0] = 2.3
paramHigh[0] = 2.8
paramLow[1] = 0.001
elif datasetName == "pores":
pass
# paramLow[0] = 1.0
# paramHigh[0] = 2.8
# paramLow[1] = 0.01
# paramHigh[1] = 0.45
elif datasetName == "rubber":
pass
# paramLow[0] = 1.0
# paramHigh[0] = 2.8
# paramLow[1] = 0.01
# paramHigh[1] = 0.25
elif datasetName == "tread":
pass
# paramLow[0] = 1.0
# paramHigh[0] = 2.5
# paramLow[1] = 0.001
# paramHigh[1] = 0.01
if quantileParametrisation == parametrisations.InterpSingleSpline:
paramHigh[1] = 6
paramHigh[0] = 2.3
paramLow[0] = 1.5
"""
Kernel composition
"""
# composition = ["linear", "+", "linear_no_bias", "*", "bbq"]
# composition = ["linear", "+", "bbq"]
# composition = ["linear", "*", "linear_no_bias", "+", "bbq"]
# composition = ["linear", "+", "linear_no_bias", "*", "bbq"]
composition = ["bbq"]
if datasetName == "co2":
# composition = ["linear", "*", "linear_no_bias", "+", "bbq"]
composition = ["linear_no_bias", "+", "bbq"]
elif datasetName == "airline":
composition = ["linear", "+", "linear", "*", "bbq"]
# composition = ["linear", "*", "linear_no_bias", "+",
# "linear", "*", "bbq"]
# composition = ["linear", "*", "linear_no_bias", "+",
# "linear", "*", "linear_no_bias", "*", "bbq", "+", "bbq"]
if basicRBF:
# composition = ["rbf" if e == "bbq" else e for e in composition]
composition = ["rbf"]
qp.paramLow = np.array([-3])
qp.paramHigh = np.array([0])
qp.logScaleParams = np.array([True])
paramLow = qp.paramLow
paramHigh = qp.paramHigh
"""
Search/optimisation for best quantile
"""
if useARDkernel:
paramLow = np.array(D * list(paramLow))
paramHigh = np.array(D * list(paramHigh))
qp.logScaleParams = np.array(D * list(qp.logScaleParams))
if learnBeta:
paramLow = np.array([-3] + list(paramLow))
paramHigh = np.array([3] + list(paramHigh))
print("parameter space high: {}".format(paramHigh))
print("parameter space low: {}".format(paramLow))
score, allParams, bo = None, None, None
if searchStrategy == "Gridsearch":
assert (len(paramLow) == 2 and "Gridsearch only designed for 2 params")
X, Y = np.meshgrid(np.linspace(paramLow[0], paramHigh[0], gridRes),
np.linspace(paramLow[1], paramHigh[1], gridRes))
allParams = np.hstack([X.reshape(-1, 1), Y.reshape(-1, 1)])
score = np.zeros((gridRes ** 2,))
for i in tqdm(range(allParams.shape[0])):
if learnBeta:
blrBeta = 10 ** (allParams[i, 0])
curParams = allParams[i, 1:]
else:
curParams = allParams[i, :]
scaledParams = scaleParams(curParams)
score[i] = -train_model(scaledParams, blrBeta)
elif searchStrategy == "BO":
search_int = np.vstack([np.atleast_2d(paramLow),
np.atleast_2d(paramHigh)]).T
bo = None # BO.BO(search_int, acq_fun=BO.UCB(boKappa), opt_maxeval=20,
allParams = np.zeros((nBOIter, len(paramLow)))
score = np.zeros((nBOIter,))
for i in tqdm(range(nBOIter)):
allParams[i, :] = bo.next_sample()
if learnBeta:
blrBeta = 10 ** (allParams[i, 0])
curParams = allParams[i, 1:]
else:
curParams = allParams[i, :]
scaledParams = scaleParams(curParams)
score[i] = -train_model(scaledParams, blrBeta)
bo.update(allParams[i, :].reshape(1, -1),
np.array(score[i]).reshape(-1, 1))
elif searchStrategy == "NLopt":
allParams = np.zeros((nlOptIter, len(paramLow)))
score = np.zeros((nlOptIter,))
pbar = tqdm(total=nlOptIter)
i = 0
# Nlopt params
opt = nlopt.opt(nlOptAlgo, len(paramLow))
opt.set_lower_bounds(np.array(paramLow).reshape(-1))
opt.set_upper_bounds(np.array(paramHigh).reshape(-1))
opt.set_maxeval(nlOptIter)
def
|
_fun_maximize
|
identifier_name
|
|
example_all.py
|
"linear", "*", "bbq"]
# composition = ["linear", "*", "linear_no_bias", "+",
# "linear", "*", "linear_no_bias", "*", "bbq", "+", "bbq"]
if basicRBF:
# composition = ["rbf" if e == "bbq" else e for e in composition]
composition = ["rbf"]
qp.paramLow = np.array([-3])
qp.paramHigh = np.array([0])
qp.logScaleParams = np.array([True])
paramLow = qp.paramLow
paramHigh = qp.paramHigh
"""
Search/optimisation for best quantile
"""
if useARDkernel:
paramLow = np.array(D * list(paramLow))
paramHigh = np.array(D * list(paramHigh))
qp.logScaleParams = np.array(D * list(qp.logScaleParams))
if learnBeta:
paramLow = np.array([-3] + list(paramLow))
paramHigh = np.array([3] + list(paramHigh))
print("parameter space high: {}".format(paramHigh))
print("parameter space low: {}".format(paramLow))
score, allParams, bo = None, None, None
if searchStrategy == "Gridsearch":
assert (len(paramLow) == 2 and "Gridsearch only designed for 2 params")
X, Y = np.meshgrid(np.linspace(paramLow[0], paramHigh[0], gridRes),
np.linspace(paramLow[1], paramHigh[1], gridRes))
allParams = np.hstack([X.reshape(-1, 1), Y.reshape(-1, 1)])
score = np.zeros((gridRes ** 2,))
for i in tqdm(range(allParams.shape[0])):
if learnBeta:
blrBeta = 10 ** (allParams[i, 0])
curParams = allParams[i, 1:]
else:
curParams = allParams[i, :]
scaledParams = scaleParams(curParams)
score[i] = -train_model(scaledParams, blrBeta)
elif searchStrategy == "BO":
search_int = np.vstack([np.atleast_2d(paramLow),
np.atleast_2d(paramHigh)]).T
bo = None # BO.BO(search_int, acq_fun=BO.UCB(boKappa), opt_maxeval=20,
allParams = np.zeros((nBOIter, len(paramLow)))
score = np.zeros((nBOIter,))
for i in tqdm(range(nBOIter)):
allParams[i, :] = bo.next_sample()
if learnBeta:
blrBeta = 10 ** (allParams[i, 0])
curParams = allParams[i, 1:]
else:
curParams = allParams[i, :]
scaledParams = scaleParams(curParams)
score[i] = -train_model(scaledParams, blrBeta)
bo.update(allParams[i, :].reshape(1, -1),
np.array(score[i]).reshape(-1, 1))
elif searchStrategy == "NLopt":
allParams = np.zeros((nlOptIter, len(paramLow)))
score = np.zeros((nlOptIter,))
pbar = tqdm(total=nlOptIter)
i = 0
# Nlopt params
opt = nlopt.opt(nlOptAlgo, len(paramLow))
opt.set_lower_bounds(np.array(paramLow).reshape(-1))
opt.set_upper_bounds(np.array(paramHigh).reshape(-1))
opt.set_maxeval(nlOptIter)
def _fun_maximize(_x, grad):
global i
if i == nlOptIter:
print("Warning: maximum number of iterations reached.")
return float(np.min(score))
allParams[i, :] = _x
if learnBeta:
global blrBeta
blrBeta = 10 ** (allParams[i, 0])
curParams = allParams[i, 1:]
else:
curParams = allParams[i, :]
scaledParams = scaleParams(curParams)
curScore = float(-train_model(scaledParams, blrBeta))
# Keep track of previous tries
score[i] = curScore
i += 1
pbar.update(1)
return curScore
opt.set_max_objective(_fun_maximize)
init_opt = np.random.uniform(0, 1, len(paramLow)) * \
(paramHigh - paramLow) + paramLow
opt.optimize(init_opt)
pbar.close()
"""
Saving
"""
# Compute best quantile
imax = np.argmax(score)
curParams = allParams[imax, :]
if learnBeta:
curParams = allParams[imax, 1:]
blrBeta = 10 ** allParams[imax, 0]
print("Best BLR beta: {}".format(blrBeta))
bestParam = scaleParams(curParams)
print("Best parameters: {}".format(bestParam))
bbq_qf = None
if not basicRBF:
# Interpolation
if useARDkernel:
bbq_qf = []
nprm = len(bestParam)
for j in range(D):
x, y, params = genParams(
bestParam[int(j * nprm / D):int((j + 1) * nprm / D)])
bbq_qf.append(InterpWithAsymptotes(x=x, y=y,
interpolator=interpolator,
params=params))
else:
x, y, params = genParams(bestParam)
bbq_qf = InterpWithAsymptotes(x=x, y=y, interpolator=interpolator,
params=params)
# Draw features with interpolated quantile
f_dict = {"linear_no_bias": ff.Linear(d=D, has_bias_term=False),
"linear": ff.Linear(d=D, has_bias_term=True)}
if basicRBF:
f_dict["rbf"] = ff.RFF_RBF(m=M, d=D, ls=bestParam)
else:
f_dict["bbq"] = ff.QMCF_BBQ(m=M, d=D,
sampler=partial(freqGenFn, bbq_qf=bbq_qf),
sequence_type=QMC_SEQUENCE.HALTON,
scramble_type=QMC_SCRAMBLING.GENERALISED,
qmc_kwargs={QMC_KWARG.PERM: None})
qmcf_bbq = ff.FComposition(f_dict=f_dict, composition=composition)
# Compute best data fit
blr = ABLR(k_phi=qmcf_bbq, d=D, d_out=1,
alpha=blrAlpha, beta=blrBeta, log_dir=None)
blr.learn_from_history(x_trn=train_x, y_trn=train_y)
prediction = blr.predict(x_tst=train_x, pred_var=True)
pred_train, predVar_train = prediction.mean, prediction.var
# Compute final score metrics
prediction = blr.predict(x_tst=test_x, pred_var=True)
pred_test, predVar_test = prediction.mean, prediction.var
finalRMSE = np.sqrt(np.mean((pred_test - test_y) ** 2))
finalMNLL = mnll(test_y, pred_test, predVar_test)
print("Final model RMSE: {}".format(finalRMSE))
print("Final model MNLL: {}".format(finalMNLL))
settingsVars = {
"RMSE": finalRMSE,
"MNLL": finalMNLL,
"bestParam": bestParam.tolist(),
"datasetName": datasetName,
"nlOptIter": nlOptIter,
"nlOptAlgo": nlOptAlgo,
"gridRes": gridRes,
"paramLow": paramLow.tolist(),
"paramHigh": paramHigh.tolist(),
"M": M,
"N": N,
"D": D,
"blrAlpha": blrAlpha,
"blrBeta": blrBeta,
"useARDkernel": useARDkernel,
"basicRBF": basicRBF,
"quantileParametrisation": quantileParametrisation.__name__,
"scoreMetric": scoreMetric,
"searchStrategy": searchStrategy,
"composition": composition,
"interpolator": interpolator.__name__
}
rs = ResultSaver(settingsVars)
rs.save_params_and_loss(allParams, -score)
if not basicRBF:
rs.save_quantile(bbq_qf, x, y)
rs.save_pdf(bbq_qf)
if D != 2:
if D == 1:
rs.save_dataset(train_x, train_y, test_x, test_y)
rs.save_data_fit(train_x, pred_train, predVar_train,
test_x, pred_test, predVar_test)
else:
# Generate images
imSize = 130
trainIdx = np.round((train_x + 1) * (imSize - 1) / 2.0).astype(int)
testIdx = np.round((test_x + 1) * (imSize - 1) / 2.0).astype(int)
fullImg = np.zeros((imSize, imSize))
for idx, y in zip(trainIdx, train_y):
fullImg[idx[0], idx[1]] = y
for idx, y in zip(testIdx, test_y):
fullImg[idx[0], idx[1]] = y
predImg = np.zeros((imSize, imSize))
for idx, y in zip(trainIdx, pred_train):
|
predImg[idx[0], idx[1]] = y
|
conditional_block
|
|
example_all.py
|
Algo = nlopt.GN_DIRECT
# nlOptAlgo = nlopt.GN_DIRECT_L
# nlOptAlgo = nlopt.GN_ISRES
# nlOptAlgo = nlopt.GN_ESCH
# NLopt Local algotithms (derivative free)
nlOptAlgo = nlopt.LN_COBYLA
# nlOptAlgo = nlopt.LN_BOBYQA
# nlOptAlgo = nlopt.LN_SBPLX
"""
Generate dataset
"""
if datasetName == "co2":
train_data, test_data = datasets.mauna_loa()
elif datasetName == "airline":
train_data, test_data = datasets.airline_passengers()
elif datasetName == "airfoil_noise":
train_data, test_data = datasets.airfoil_noise()
elif datasetName == "concrete":
train_data, test_data = datasets.concrete()
elif datasetName == "rubber" \
or datasetName == "pores" \
or datasetName == "tread":
train_data, test_data = datasets.textures_2D(texture_name=datasetName)
else:
if datasetName == "cosine":
objectiveFunction = toy_functions.cosine
elif datasetName == "harmonics":
objectiveFunction = toy_functions.harmonics
elif datasetName == "pattern":
objectiveFunction = toy_functions.pattern
elif datasetName == "heaviside":
objectiveFunction = toy_functions.heaviside
elif datasetName == "quadraticCos":
objectiveFunction = toy_functions.quadratic_cos
elif datasetName == "steps":
objectiveFunction = toy_functions.steps
else:
raise RuntimeError("Objective function was not defined")
train_x = np.sort(np.random.uniform(-0.3, 1.2, (100, 1)), axis=0)
train_y = objectiveFunction(train_x)
train_data = np.hstack([train_x, train_y])
test_x = np.linspace(-0.5, 1.5, 1000).reshape(-1, 1)
# test_x = np.sort(np.random.uniform(-1, 1, (100, 1)), axis=0)
test_y = objectiveFunction(test_x)
test_data = np.hstack([test_x, test_y])
train_x = train_data[:, :-1]
train_y = train_data[:, [-1]]
test_x = test_data[:, :-1]
test_y = test_data[:, [-1]]
N, D = train_x.shape
print("Dataset size: {} * {}".format(N, D))
if scoreMetric == "RMSE":
Nv = int(0.2 * N)
N -= Nv
val_x = train_x[-Nv:, :]
val_y = train_y[-Nv:].reshape(-1, 1)
train_x = train_x[:-Nv, :]
train_y = train_y[:-Nv].reshape(-1, 1)
vizData = False
if vizData:
plt.figure()
plt.plot(train_x, train_y, 'b-', label="train set")
if scoreMetric == "RMSE":
plt.plot(val_x, val_y, 'g-', label="validation set")
plt.plot(test_x, test_y, 'r-', label="test set")
plt.xlim(min(np.min(train_x), np.min(test_x)) - .2,
max(np.max(train_x), np.max(test_x)) + .2)
plt.ylim(min(np.min(train_y), np.min(test_y)) - .2,
max(np.max(train_y), np.max(test_y)) + .2)
plt.title("Data set")
plt.legend(loc=2)
plt.show()
exit()
"""
Quantile parametrisation
"""
if quantileParametrisation == parametrisations.BoundedQPoints:
qp = quantileParametrisation(6, p1=(0.03, -100), p2=(0.97, 100))
elif quantileParametrisation == parametrisations.StairCase:
qp = quantileParametrisation(9, p1=(0.03, -150), p2=(0.97, 150))
else:
qp = quantileParametrisation()
genParams = qp.gen_params
interpolator = qp.interpolator
paramLow = qp.paramLow
paramHigh = qp.paramHigh
scaleParams = qp.scale_params
if datasetName == "co2":
if quantileParametrisation == parametrisations.PeriodicSimple:
paramHigh[0] = 2.3
paramLow[0] = 2
paramHigh[1] = 0.2
paramLow[1] = 0.01
elif datasetName == "airline":
if quantileParametrisation == parametrisations.PeriodicSimple:
paramLow[0] = 2.3
paramHigh[0] = 2.8
paramLow[1] = 0.001
elif datasetName == "pores":
pass
# paramLow[0] = 1.0
# paramHigh[0] = 2.8
# paramLow[1] = 0.01
# paramHigh[1] = 0.45
elif datasetName == "rubber":
pass
# paramLow[0] = 1.0
# paramHigh[0] = 2.8
# paramLow[1] = 0.01
# paramHigh[1] = 0.25
elif datasetName == "tread":
pass
# paramLow[0] = 1.0
# paramHigh[0] = 2.5
# paramLow[1] = 0.001
# paramHigh[1] = 0.01
if quantileParametrisation == parametrisations.InterpSingleSpline:
paramHigh[1] = 6
paramHigh[0] = 2.3
paramLow[0] = 1.5
"""
Kernel composition
"""
# composition = ["linear", "+", "linear_no_bias", "*", "bbq"]
# composition = ["linear", "+", "bbq"]
# composition = ["linear", "*", "linear_no_bias", "+", "bbq"]
# composition = ["linear", "+", "linear_no_bias", "*", "bbq"]
composition = ["bbq"]
if datasetName == "co2":
# composition = ["linear", "*", "linear_no_bias", "+", "bbq"]
composition = ["linear_no_bias", "+", "bbq"]
elif datasetName == "airline":
composition = ["linear", "+", "linear", "*", "bbq"]
# composition = ["linear", "*", "linear_no_bias", "+",
# "linear", "*", "bbq"]
# composition = ["linear", "*", "linear_no_bias", "+",
# "linear", "*", "linear_no_bias", "*", "bbq", "+", "bbq"]
if basicRBF:
# composition = ["rbf" if e == "bbq" else e for e in composition]
composition = ["rbf"]
qp.paramLow = np.array([-3])
qp.paramHigh = np.array([0])
qp.logScaleParams = np.array([True])
|
"""
Search/optimisation for best quantile
"""
if useARDkernel:
paramLow = np.array(D * list(paramLow))
paramHigh = np.array(D * list(paramHigh))
qp.logScaleParams = np.array(D * list(qp.logScaleParams))
if learnBeta:
paramLow = np.array([-3] + list(paramLow))
paramHigh = np.array([3] + list(paramHigh))
print("parameter space high: {}".format(paramHigh))
print("parameter space low: {}".format(paramLow))
score, allParams, bo = None, None, None
if searchStrategy == "Gridsearch":
assert (len(paramLow) == 2 and "Gridsearch only designed for 2 params")
X, Y = np.meshgrid(np.linspace(paramLow[0], paramHigh[0], gridRes),
np.linspace(paramLow[1], paramHigh[1], gridRes))
allParams = np.hstack([X.reshape(-1, 1), Y.reshape(-1, 1)])
score = np.zeros((gridRes ** 2,))
for i in tqdm(range(allParams.shape[0])):
if learnBeta:
blrBeta = 10 ** (allParams[i, 0])
curParams = allParams[i, 1:]
else:
curParams = allParams[i, :]
scaledParams = scaleParams(curParams)
score[i] = -train_model(scaledParams, blrBeta)
elif searchStrategy == "BO":
search_int = np.vstack([np.atleast_2d(paramLow),
np.atleast_2d(paramHigh)]).T
bo = None # BO.BO(search_int, acq_fun=BO.UCB(boKappa), opt_maxeval=20,
allParams = np.zeros((nBOIter, len(paramLow)))
score = np.zeros((nBOIter,))
for i in tqdm(range(nBO
|
paramLow = qp.paramLow
paramHigh = qp.paramHigh
|
random_line_split
|
lib.rs
|
OneShot%3E%2C%20i16%2C%20CH%3E
//! [`set_data_rate()`]: struct.Ads1x1x.html#method.set_data_rate
//! [`set_full_scale_range()`]: struct.Ads1x1x.html#method.set_full_scale_range
//! [`is_measurement_in_progress()`]: struct.Ads1x1x.html#method.is_measurement_in_progress
//! [`set_high_threshold_raw()`]: struct.Ads1x1x.html#method.set_high_threshold_raw
//! [`set_comparator_mode()`]: struct.Ads1x1x.html#method.set_comparator_mode
//! [`set_comparator_polarity()`]: struct.Ads1x1x.html#method.set_comparator_polarity
//! [`set_comparator_latching()`]: struct.Ads1x1x.html#method.set_comparator_latching
//! [`set_comparator_queue()`]: struct.Ads1x1x.html#method.set_comparator_queue
//! [`disable_comparator()`]: struct.Ads1x1x.html#method.disable_comparator
//! [`use_alert_rdy_pin_as_ready()`]: struct.Ads1x1x.html#method.use_alert_rdy_pin_as_ready
//!
//! ## The devices
//!
//! The devices are precision, low power, 12/16-bit analog-to-digital
//! converters (ADC) that provide all features necessary to measure the most
//! common sensor signals in an ultra-small package. Depending on the device,
//! these integrate a programmable gain amplifier (PGA), voltage reference,
//! oscillator and high-accuracy temperature sensor.
//!
//! The devices can perform conversions at data rates up to 3300 samples per
//! second (SPS). The PGA offers input ranges from ±256 mV to ±6.144 V,
//! allowing both large and small signals to be measured with high resolution.
//! An input multiplexer (MUX) allows to measure two differential or four
//! single-ended inputs. The high-accuracy temperature sensor can be used for
//! system-level temperature monitoring or cold-junction compensation for
//! thermocouples.
//!
//! The devices operate either in continuous-conversion mode, or in a
//! single-shot mode that automatically powers down after a conversion.
//! Single-shot mode significantly reduces current consumption during idle
//! periods. Data is transferred through I2C.
//!
//! Here is a comparison of the caracteristics of the devices:
//!
//! | Device | Resolution | Sample Rate | Channels | Multi-channel | Features |
//! |---------|------------|--------------|----------|---------------|-----------------|
//! | ADS1013 | 12-bit | Max 3300 SPS | 1 | N/A | |
//! | ADS1014 | 12-bit | Max 3300 SPS | 1 | N/A | Comparator, PGA |
//! | ADS1015 | 12-bit | Max 3300 SPS | 4 | Multiplexed | Comparator, PGA |
//! | ADS1113 | 16-bit | Max 860 SPS | 1 | N/A | |
//! | ADS1114 | 16-bit | Max 860 SPS | 1 | N/A | Comparator, PGA |
//! | ADS1115 | 16-bit | Max 860 SPS | 4 | Multiplexed | Comparator, PGA |
//!
//! Datasheets:
//! - [ADS101x](http://www.ti.com/lit/ds/symlink/ads1015.pdf)
//! - [ADS111x](http://www.ti.com/lit/ds/symlink/ads1115.pdf)
//!
//! ## Usage examples (see also examples folder)
//!
//! To use this driver, import this crate and an `embedded_hal` implementation,
//! then instantiate the appropriate device.
//! In the following examples an instance of the device ADS1013 will be created
//! as an example. Other devices can be created with similar methods like:
//! `Ads1x1x::new_ads1114(...)`.
//!
//! Please find additional examples using hardware in this repository: [driver-examples]
//!
//! [driver-examples]: https://github.com/eldruin/driver-examples
//!
//! ### Create a driver instance for the ADS1013
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{Ads1x1x, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let address = SlaveAddr::default();
//! let adc = Ads1x1x::new_ads1013(dev, address);
//! // do something...
//!
//! // get the I2C device back
//! let dev = adc.destroy_ads1013();
//! ```
//!
//! ### Create a driver instance for the ADS1013 with an alternative address (method 1)
//!
|
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{Ads1x1x, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let (bit1, bit0) = (true, false); // last two bits of address
//! let address = SlaveAddr::Alternative(bit1, bit0);
//! let adc = Ads1x1x::new_ads1013(dev, address);
//! ```
//! ### Create a driver instance for the ADS1013 with an alternative address (method 2)
//!
//! Using helper `SlaveAddr` creation method depending on the connection of
//! the `ADDR` pin.
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{Ads1x1x, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! // `ADDR` pin connected to SDA results in the 0x4A effective address
//! let address = SlaveAddr::new_sda();
//! let adc = Ads1x1x::new_ads1013(dev, address);
//! ```
//!
//! ### Make a one-shot measurement
//! ```no_run
//! use ads1x1x::{channel, Ads1x1x, SlaveAddr};
//! use embedded_hal::adc::OneShot;
//! use linux_embedded_hal::I2cdev;
//! use nb::block;
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let mut adc = Ads1x1x::new_ads1013(dev, SlaveAddr::default());
//! let measurement = block!(adc.read(&mut channel::DifferentialA0A1)).unwrap();
//! println!("Measurement: {}", measurement);
//! let _dev = adc.destroy_ads1013(); // get I2C device back
//! ```
//!
//! ### Change into continuous conversion mode and read the last measurement
//!
//! Changing the mode may fail in case there was a communication error.
//! In this case, you can retrieve the unchanged device from the error type.
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{Ads1x1x, ModeChangeError, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let address = SlaveAddr::default();
//! let adc = Ads1x1x::new_ads1013(dev, address);
//! match adc.into_continuous() {
//! Err(ModeChangeError::I2C(e, adc)) => /* mode change failed handling */ panic!(),
//! Ok(mut adc) => {
//! let measurement = adc.read().unwrap();
//! // ...
//! }
//! }
//! ```
//!
//!
//! ### Set the data rate
//! For 12-bit devices, the available data rates are given by `DataRate12Bit`.
//! For 16-bit devices, the available data rates are given by `DataRate16Bit`.
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{Ads1x1x, DataRate16Bit, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let address = SlaveAddr::default();
//! let mut adc = Ads1x1x::new_ads1115(dev, address);
//! adc.set_data_rate(DataRate16Bit::Sps860).unwrap();
//! ```
//!
//! ### Configure the comparator
//! Configure the comparator to assert when the voltage drops below -1.5V
//! or goes above 1.5V in at least two consecutive conversions. Then the
//! ALERT/RDY pin will be set high and it will be kept so until the
//! measurement is read or an appropriate SMBus alert response is sent by
//! the master.
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{
//! Ads1x1x, SlaveAddr, ComparatorQueue, ComparatorPolarity,
//! ComparatorMode, ComparatorLatching, FullScaleRange
//! };
//!
//! let dev = I2cdev::new("/dev/i2c-1
|
random_line_split
|
|
lib.rs
|
[`disable_comparator()`]: struct.Ads1x1x.html#method.disable_comparator
//! [`use_alert_rdy_pin_as_ready()`]: struct.Ads1x1x.html#method.use_alert_rdy_pin_as_ready
//!
//! ## The devices
//!
//! The devices are precision, low power, 12/16-bit analog-to-digital
//! converters (ADC) that provide all features necessary to measure the most
//! common sensor signals in an ultra-small package. Depending on the device,
//! these integrate a programmable gain amplifier (PGA), voltage reference,
//! oscillator and high-accuracy temperature sensor.
//!
//! The devices can perform conversions at data rates up to 3300 samples per
//! second (SPS). The PGA offers input ranges from ±256 mV to ±6.144 V,
//! allowing both large and small signals to be measured with high resolution.
//! An input multiplexer (MUX) allows to measure two differential or four
//! single-ended inputs. The high-accuracy temperature sensor can be used for
//! system-level temperature monitoring or cold-junction compensation for
//! thermocouples.
//!
//! The devices operate either in continuous-conversion mode, or in a
//! single-shot mode that automatically powers down after a conversion.
//! Single-shot mode significantly reduces current consumption during idle
//! periods. Data is transferred through I2C.
//!
//! Here is a comparison of the caracteristics of the devices:
//!
//! | Device | Resolution | Sample Rate | Channels | Multi-channel | Features |
//! |---------|------------|--------------|----------|---------------|-----------------|
//! | ADS1013 | 12-bit | Max 3300 SPS | 1 | N/A | |
//! | ADS1014 | 12-bit | Max 3300 SPS | 1 | N/A | Comparator, PGA |
//! | ADS1015 | 12-bit | Max 3300 SPS | 4 | Multiplexed | Comparator, PGA |
//! | ADS1113 | 16-bit | Max 860 SPS | 1 | N/A | |
//! | ADS1114 | 16-bit | Max 860 SPS | 1 | N/A | Comparator, PGA |
//! | ADS1115 | 16-bit | Max 860 SPS | 4 | Multiplexed | Comparator, PGA |
//!
//! Datasheets:
//! - [ADS101x](http://www.ti.com/lit/ds/symlink/ads1015.pdf)
//! - [ADS111x](http://www.ti.com/lit/ds/symlink/ads1115.pdf)
//!
//! ## Usage examples (see also examples folder)
//!
//! To use this driver, import this crate and an `embedded_hal` implementation,
//! then instantiate the appropriate device.
//! In the following examples an instance of the device ADS1013 will be created
//! as an example. Other devices can be created with similar methods like:
//! `Ads1x1x::new_ads1114(...)`.
//!
//! Please find additional examples using hardware in this repository: [driver-examples]
//!
//! [driver-examples]: https://github.com/eldruin/driver-examples
//!
//! ### Create a driver instance for the ADS1013
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{Ads1x1x, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let address = SlaveAddr::default();
//! let adc = Ads1x1x::new_ads1013(dev, address);
//! // do something...
//!
//! // get the I2C device back
//! let dev = adc.destroy_ads1013();
//! ```
//!
//! ### Create a driver instance for the ADS1013 with an alternative address (method 1)
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{Ads1x1x, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let (bit1, bit0) = (true, false); // last two bits of address
//! let address = SlaveAddr::Alternative(bit1, bit0);
//! let adc = Ads1x1x::new_ads1013(dev, address);
//! ```
//! ### Create a driver instance for the ADS1013 with an alternative address (method 2)
//!
//! Using helper `SlaveAddr` creation method depending on the connection of
//! the `ADDR` pin.
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{Ads1x1x, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! // `ADDR` pin connected to SDA results in the 0x4A effective address
//! let address = SlaveAddr::new_sda();
//! let adc = Ads1x1x::new_ads1013(dev, address);
//! ```
//!
//! ### Make a one-shot measurement
//! ```no_run
//! use ads1x1x::{channel, Ads1x1x, SlaveAddr};
//! use embedded_hal::adc::OneShot;
//! use linux_embedded_hal::I2cdev;
//! use nb::block;
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let mut adc = Ads1x1x::new_ads1013(dev, SlaveAddr::default());
//! let measurement = block!(adc.read(&mut channel::DifferentialA0A1)).unwrap();
//! println!("Measurement: {}", measurement);
//! let _dev = adc.destroy_ads1013(); // get I2C device back
//! ```
//!
//! ### Change into continuous conversion mode and read the last measurement
//!
//! Changing the mode may fail in case there was a communication error.
//! In this case, you can retrieve the unchanged device from the error type.
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{Ads1x1x, ModeChangeError, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let address = SlaveAddr::default();
//! let adc = Ads1x1x::new_ads1013(dev, address);
//! match adc.into_continuous() {
//! Err(ModeChangeError::I2C(e, adc)) => /* mode change failed handling */ panic!(),
//! Ok(mut adc) => {
//! let measurement = adc.read().unwrap();
//! // ...
//! }
//! }
//! ```
//!
//!
//! ### Set the data rate
//! For 12-bit devices, the available data rates are given by `DataRate12Bit`.
//! For 16-bit devices, the available data rates are given by `DataRate16Bit`.
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{Ads1x1x, DataRate16Bit, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let address = SlaveAddr::default();
//! let mut adc = Ads1x1x::new_ads1115(dev, address);
//! adc.set_data_rate(DataRate16Bit::Sps860).unwrap();
//! ```
//!
//! ### Configure the comparator
//! Configure the comparator to assert when the voltage drops below -1.5V
//! or goes above 1.5V in at least two consecutive conversions. Then the
//! ALERT/RDY pin will be set high and it will be kept so until the
//! measurement is read or an appropriate SMBus alert response is sent by
//! the master.
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use ads1x1x::{
//! Ads1x1x, SlaveAddr, ComparatorQueue, ComparatorPolarity,
//! ComparatorMode, ComparatorLatching, FullScaleRange
//! };
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let address = SlaveAddr::default();
//! let mut adc = Ads1x1x::new_ads1015(dev, address);
//! adc.set_comparator_queue(ComparatorQueue::Two).unwrap();
//! adc.set_comparator_polarity(ComparatorPolarity::ActiveHigh).unwrap();
//! adc.set_comparator_mode(ComparatorMode::Window).unwrap();
//! adc.set_full_scale_range(FullScaleRange::Within2_048V).unwrap();
//! adc.set_low_threshold_raw(-1500).unwrap();
//! adc.set_high_threshold_raw(1500).unwrap();
//! adc.set_comparator_latching(ComparatorLatching::Latching).unwrap();
//! ```
#![doc(html_root_url = "https://docs.rs/ads1x1x/0.2.2")]
#![deny(unsafe_code)]
#![deny(missing_docs)]
#![no_std]
const DEVICE_BASE_ADDRESS: u8 = 0b100_1000;
struct Re
|
gister;
|
identifier_name
|
|
shear_calculation_withoutplot_vasp.py
|
3)) ####read basis vector from POSCAR
print(pos_array)
oa=np.array([pos_array[0][0], pos_array[0][1], pos_array[0][2]])
ob=np.array([pos_array[1][0], pos_array[1][1], pos_array[1][2]])
oc=np.array([pos_array[2][0], pos_array[2][1], pos_array[2][2]])
#------------------------------------------------------------------------------------
###start to calculate the structure data before rotation######
##a1_len=(float(pos_array[0][0])**2+float(pos_array[0][1])**2+float(pos_array[0][2])**2)**0.5
##a2_len=(float(pos_array[1][0])**2+float(pos_array[1][1])**2+float(pos_array[1][2])**2)**0.5
##a3_len=(float(pos_array[2][0])**2+float(pos_array[2][1])**2+float(pos_array[2][2])**2)**0.5
##
##P=np.array([P0[0]*a1_len,P0[1]*a2_len,P0[2]*a3_len])
##Q=np.array([Q0[0]*a1_len,Q0[1]*a2_len,Q0[2]*a3_len])
##
##XYZ_a=np.array([[a1_len, 0, 0],
## [0, a2_len, 0],
## [0, 0, a3_len]])
#----------------------------------------
basis=np.array([oa, ob, oc])
P0_abc=np.array([[P0[0], 0, 0],
[0, P0[1], 0],
[0, 0, P0[2]]])
P0_abc_basis=np.dot(P0_abc,basis)
P=P0_abc_basis[0]+P0_abc_basis[1]+P0_abc_basis[2] # the position of the normal of shear plane before rotation
Q0_abc=np.array([[Q0[0], 0, 0],
[0, Q0[1], 0],
[0, 0, Q0[2]]])
Q0_abc_basis=np.dot(Q0_abc,basis)
Q=Q0_abc_basis[0]+Q0_abc_basis[1]+Q0_abc_basis[2] # the position of the normal of shear plane after rotation
#----------------------------------------
#basis=np.array([oa, ob, oc])
L0_abc=np.array([[L0[0], 0, 0],
[0, L0[1], 0],
[0, 0, L0[2]]])
L0_abc_basis=np.dot(L0_abc,basis)
L=L0_abc_basis[0]+L0_abc_basis[1]+L0_abc_basis[2] # the position of shear direction before rotation
K0_abc=np.array([[K0[0], 0, 0],
[0, K0[1], 0],
[0, 0, K0[2]]])
K0_abc_basis=np.dot(K0_abc,basis)
K=K0_abc_basis[0]+K0_abc_basis[1]+K0_abc_basis[2] # the position of shear direction after rotation
#------------------------------------------------------------------------------------
###start to calculate the structure data after rotation######
############## the first rotation begin##############
######1.get the angel between two vectors########
P_norm=(P[0]**2+P[1]**2+P[2]**2)**0.5 #the norm of vetor before roation
Q_norm=(Q[0]**2+Q[1]**2+Q[2]**2)**0.5 #the norm of vetor after roation
PQ_dot=np.dot(P,Q)
theta=math.acos(PQ_dot/(P_norm*Q_norm))##obtain theta, the unit is radian instead of degree
theta_cos=PQ_dot/(P_norm*Q_norm)
theta_sin=math.sin(theta)
######2.get the rotation axis##############
M=np.array([P[1]*Q[2]-P[2]*Q[1], P[2]*Q[0]-P[0]*Q[2], P[0]*Q[1]-P[1]*Q[0]])
M_norm=(M[0]**2+M[1]**2+M[2]**2)**0.5 #the norm of M vetor
M_unit=np.array([M[0]/M_norm, M[1]/M_norm, M[2]/M_norm])
######3.get the rotation matrix###########
Nx=M_unit[0]
Ny=M_unit[1]
Nz=M_unit[2]
PQ_rot=np.array([[Nx*Nx*(1-theta_cos)+theta_cos, Nx*Ny*(1-theta_cos)+Nz*theta_sin, Nx*Nz*(1-theta_cos)-Ny*theta_sin],
[Nx*Ny*(1-theta_cos)-Nz*theta_sin, Ny*Ny*(1-theta_cos)+theta_cos, Ny*Nz*(1-theta_cos)+Nx*theta_sin],
[Nx*Nz*(1-theta_cos)+Ny*theta_sin, Ny*Nz*(1-theta_cos)-Nx*theta_sin, Nz*Nz*(1-theta_cos)+theta_cos]])
###### #####
a_PQ_rot=np.dot(pos_array,PQ_rot) #three basis vector after rotation
a_PQ_rot=a_PQ_rot.tolist()
L_rot=np.dot(L,PQ_rot)
############## the second rotation begin##############
######1.get the angel between two vectors########
L_norm=(L_rot[0]**2+L_rot[1]**2+L_rot[2]**2)**0.5 #the norm of vetor before roation
K_norm=(K[0]**2+K[1]**2+K[2]**2)**0.5 #the norm of vetor after roation
LK_dot=np.dot(L_rot,K)
theta=math.acos(LK_dot/(L_norm*K_norm))##obtain theta, the unit is radian instead of degree
theta_cos=LK_dot/(L_norm*K_norm)
theta_sin=math.sin(theta)
######2.get the rotation axis##############
H=np.array([L_rot[1]*K[2]-L_rot[2]*K[1], L_rot[2]*K[0]-L_rot[0]*K[2], L_rot[0]*K[1]-L_rot[1]*K[0]])
H_norm=(H[0]**2+H[1]**2+H[2]**2)**0.5 #the norm of M vetor
H_unit=np.array([H[0]/H_norm, H[1]/H_norm, H[2]/H_norm])
######3.get the rotation matrix###########
Ex=H_unit[0]
Ey=H_unit[1]
Ez=H_unit[2]
LK_rot=np.array([[Ex*Ex*(1-theta_cos)+theta_cos, Ex*Ey*(1-theta_cos)+Ez*theta_sin, Ex*Ez*(1-theta_cos)-Ey*theta_sin],
[Ex*Ey*(1-theta_cos)-Ez*theta_sin, Ey*Ey*(1-theta_cos)+theta_cos, Ey*Ez*(1-theta_cos)+Ex*theta_sin],
[Ex*Ez*(1-theta_cos)+Ey*theta_sin, Ey*Nz*(1-theta_cos)-Ex*theta_sin, Ez*Ez*(1-theta_cos)+theta_cos]])
###### #####
a_LK_rot=np.dot(a_PQ_rot,LK_rot) #three basis vector after rotation
a_LK_rot=a_LK_rot.tolist()
os.system("cp POSCAR POSCAR_original") #copy original POSCAR
r=[]
with open ("POSCAR") as poscar1:
for line in poscar1:
r.append(line)
f=open("POSCAR_rota","w") #write POSCAR after rotation as POSCAR_rota
for i in range(0,2):
f.write(r[i])
for j in range(len(a_LK_rot)):
f.write(str(a_LK_rot[j][0])+' ')
f.write(str(a_LK_rot[j][1])+' ')
f.write(str(a_LK_rot[j][2]))
f.write('\n')
for x in range(5,len(r)):
f.write(r[x])
f.close()
os.system("cp POSCAR_rota POSCAR") ## copy POSCAR_rota as POSCAR
###### Thirdly,apply tensile strain to the rotated basis vector
def postrain(poscar):
|
t2=[]
t3=[]
with open (poscar) as poscar2:
pos2=poscar2.readlines()
length=len(pos2)
for i in range(2,5):
j=pos2[i]
j=j.split()
t2.extend(j)
for i in range(len(t2)):
t3.extend([float(t2[i])])
pos_array3=np.array(t3).reshape((3,3))
if (Q0==np.array([1, 0, 0])).all():
stra_matr=np.array([[1,0,stra],
[0,1,0],
[stra,0,1]]) # strain(xz) and strain(zx)
a_stra=np.dot(pos_array3,stra_matr)
with open (poscar) as poscar:
s=[]
for line in poscar:
|
identifier_body
|
|
shear_calculation_withoutplot_vasp.py
|
, 0]
#P0=np.array([1, 1, 1]) #provide the axis before rotation.. P0 is the tensile direction we want to calculate.
###finish to read the input file
#Q0=np.array([1, 0, 0]) #after rotation. Q0 is the x axis. Since the x axis will not be optimized as we set in VASP, so Q0 is [1, 0, 0]
#------------------------------------------------------------------------------------
###open POSCAR
t=[]
t1=[]
with open ("POSCAR") as poscar0:
pos0=poscar0.readlines()
length=len(pos0)
for i in range(2,5):
j=pos0[i]
j=j.split()
t.extend(j)
print(t)
for i in range(len(t)):
t1.extend([float(t[i])])
pos_array=np.array(t1).reshape((3,3)) ####read basis vector from POSCAR
print(pos_array)
oa=np.array([pos_array[0][0], pos_array[0][1], pos_array[0][2]])
ob=np.array([pos_array[1][0], pos_array[1][1], pos_array[1][2]])
oc=np.array([pos_array[2][0], pos_array[2][1], pos_array[2][2]])
#------------------------------------------------------------------------------------
###start to calculate the structure data before rotation######
##a1_len=(float(pos_array[0][0])**2+float(pos_array[0][1])**2+float(pos_array[0][2])**2)**0.5
##a2_len=(float(pos_array[1][0])**2+float(pos_array[1][1])**2+float(pos_array[1][2])**2)**0.5
##a3_len=(float(pos_array[2][0])**2+float(pos_array[2][1])**2+float(pos_array[2][2])**2)**0.5
##
##P=np.array([P0[0]*a1_len,P0[1]*a2_len,P0[2]*a3_len])
##Q=np.array([Q0[0]*a1_len,Q0[1]*a2_len,Q0[2]*a3_len])
##
##XYZ_a=np.array([[a1_len, 0, 0],
## [0, a2_len, 0],
## [0, 0, a3_len]])
#----------------------------------------
basis=np.array([oa, ob, oc])
P0_abc=np.array([[P0[0], 0, 0],
[0, P0[1], 0],
[0, 0, P0[2]]])
P0_abc_basis=np.dot(P0_abc,basis)
P=P0_abc_basis[0]+P0_abc_basis[1]+P0_abc_basis[2] # the position of the normal of shear plane before rotation
Q0_abc=np.array([[Q0[0], 0, 0],
[0, Q0[1], 0],
[0, 0, Q0[2]]])
Q0_abc_basis=np.dot(Q0_abc,basis)
Q=Q0_abc_basis[0]+Q0_abc_basis[1]+Q0_abc_basis[2] # the position of the normal of shear plane after rotation
#----------------------------------------
#basis=np.array([oa, ob, oc])
L0_abc=np.array([[L0[0], 0, 0],
[0, L0[1], 0],
[0, 0, L0[2]]])
L0_abc_basis=np.dot(L0_abc,basis)
L=L0_abc_basis[0]+L0_abc_basis[1]+L0_abc_basis[2] # the position of shear direction before rotation
K0_abc=np.array([[K0[0], 0, 0],
[0, K0[1], 0],
[0, 0, K0[2]]])
K0_abc_basis=np.dot(K0_abc,basis)
K=K0_abc_basis[0]+K0_abc_basis[1]+K0_abc_basis[2] # the position of shear direction after rotation
#------------------------------------------------------------------------------------
###start to calculate the structure data after rotation######
############## the first rotation begin##############
######1.get the angel between two vectors########
P_norm=(P[0]**2+P[1]**2+P[2]**2)**0.5 #the norm of vetor before roation
Q_norm=(Q[0]**2+Q[1]**2+Q[2]**2)**0.5 #the norm of vetor after roation
PQ_dot=np.dot(P,Q)
theta=math.acos(PQ_dot/(P_norm*Q_norm))##obtain theta, the unit is radian instead of degree
theta_cos=PQ_dot/(P_norm*Q_norm)
theta_sin=math.sin(theta)
######2.get the rotation axis##############
M=np.array([P[1]*Q[2]-P[2]*Q[1], P[2]*Q[0]-P[0]*Q[2], P[0]*Q[1]-P[1]*Q[0]])
M_norm=(M[0]**2+M[1]**2+M[2]**2)**0.5 #the norm of M vetor
M_unit=np.array([M[0]/M_norm, M[1]/M_norm, M[2]/M_norm])
######3.get the rotation matrix###########
Nx=M_unit[0]
Ny=M_unit[1]
Nz=M_unit[2]
PQ_rot=np.array([[Nx*Nx*(1-theta_cos)+theta_cos, Nx*Ny*(1-theta_cos)+Nz*theta_sin, Nx*Nz*(1-theta_cos)-Ny*theta_sin],
[Nx*Ny*(1-theta_cos)-Nz*theta_sin, Ny*Ny*(1-theta_cos)+theta_cos, Ny*Nz*(1-theta_cos)+Nx*theta_sin],
[Nx*Nz*(1-theta_cos)+Ny*theta_sin, Ny*Nz*(1-theta_cos)-Nx*theta_sin, Nz*Nz*(1-theta_cos)+theta_cos]])
###### #####
a_PQ_rot=np.dot(pos_array,PQ_rot) #three basis vector after rotation
a_PQ_rot=a_PQ_rot.tolist()
L_rot=np.dot(L,PQ_rot)
############## the second rotation begin##############
######1.get the angel between two vectors########
L_norm=(L_rot[0]**2+L_rot[1]**2+L_rot[2]**2)**0.5 #the norm of vetor before roation
K_norm=(K[0]**2+K[1]**2+K[2]**2)**0.5 #the norm of vetor after roation
LK_dot=np.dot(L_rot,K)
theta=math.acos(LK_dot/(L_norm*K_norm))##obtain theta, the unit is radian instead of degree
theta_cos=LK_dot/(L_norm*K_norm)
theta_sin=math.sin(theta)
######2.get the rotation axis##############
H=np.array([L_rot[1]*K[2]-L_rot[2]*K[1], L_rot[2]*K[0]-L_rot[0]*K[2], L_rot[0]*K[1]-L_rot[1]*K[0]])
H_norm=(H[0]**2+H[1]**2+H[2]**2)**0.5 #the norm of M vetor
H_unit=np.array([H[0]/H_norm, H[1]/H_norm, H[2]/H_norm])
######3.get the rotation matrix###########
Ex=H_unit[0]
Ey=H_unit[1]
Ez=H_unit[2]
LK_rot=np.array([[Ex*Ex*(1-theta_cos)+theta_cos, Ex*Ey*(1-theta_cos)+Ez*theta_sin, Ex*Ez*(1-theta_cos)-Ey*theta_sin],
[Ex*Ey*(1-theta_cos)-Ez*theta_sin, Ey*Ey*(1-theta_cos)+theta_cos, Ey*Ez*(1-theta_cos)+Ex*theta_sin],
[Ex*Ez*(1-theta_cos)+Ey*theta_sin, Ey*Nz*(1-theta_cos)-Ex*theta_sin, Ez*Ez*(1-theta_cos)+theta_cos]])
###### #####
a_LK_rot=np.dot(a_PQ_rot,LK_rot) #three basis vector after rotation
a_LK_rot=a_LK_rot.tolist()
os.system("cp POSCAR POSCAR_original") #copy original POSCAR
r=[]
with open ("POSCAR") as poscar1:
for line in poscar1:
r.append(line)
f=open("POSCAR_rota","w") #write POSCAR after rotation as POSCAR_rota
for i in range(0,2):
f.write(r[i])
for j in range(len(a_LK_rot)):
f.write(str(a_LK_rot[j][0])+' ')
f.write(str(a_LK_rot[j][1])+' ')
f.write(str(a_LK_rot[j][2]))
f.write('\n')
for x in range(5,len(r)):
f.write(r[x])
f.close()
os.system("cp POSCAR_rota POSCAR") ## copy POSCAR_rota as POSCAR
###### Thirdly,apply tensile strain to the rotated basis vector
def
|
postrain
|
identifier_name
|
|
shear_calculation_withoutplot_vasp.py
|
_basis=np.dot(P0_abc,basis)
P=P0_abc_basis[0]+P0_abc_basis[1]+P0_abc_basis[2] # the position of the normal of shear plane before rotation
Q0_abc=np.array([[Q0[0], 0, 0],
[0, Q0[1], 0],
[0, 0, Q0[2]]])
Q0_abc_basis=np.dot(Q0_abc,basis)
Q=Q0_abc_basis[0]+Q0_abc_basis[1]+Q0_abc_basis[2] # the position of the normal of shear plane after rotation
#----------------------------------------
#basis=np.array([oa, ob, oc])
L0_abc=np.array([[L0[0], 0, 0],
[0, L0[1], 0],
[0, 0, L0[2]]])
L0_abc_basis=np.dot(L0_abc,basis)
L=L0_abc_basis[0]+L0_abc_basis[1]+L0_abc_basis[2] # the position of shear direction before rotation
K0_abc=np.array([[K0[0], 0, 0],
[0, K0[1], 0],
[0, 0, K0[2]]])
K0_abc_basis=np.dot(K0_abc,basis)
K=K0_abc_basis[0]+K0_abc_basis[1]+K0_abc_basis[2] # the position of shear direction after rotation
#------------------------------------------------------------------------------------
###start to calculate the structure data after rotation######
############## the first rotation begin##############
######1.get the angel between two vectors########
P_norm=(P[0]**2+P[1]**2+P[2]**2)**0.5 #the norm of vetor before roation
Q_norm=(Q[0]**2+Q[1]**2+Q[2]**2)**0.5 #the norm of vetor after roation
PQ_dot=np.dot(P,Q)
theta=math.acos(PQ_dot/(P_norm*Q_norm))##obtain theta, the unit is radian instead of degree
theta_cos=PQ_dot/(P_norm*Q_norm)
theta_sin=math.sin(theta)
######2.get the rotation axis##############
M=np.array([P[1]*Q[2]-P[2]*Q[1], P[2]*Q[0]-P[0]*Q[2], P[0]*Q[1]-P[1]*Q[0]])
M_norm=(M[0]**2+M[1]**2+M[2]**2)**0.5 #the norm of M vetor
M_unit=np.array([M[0]/M_norm, M[1]/M_norm, M[2]/M_norm])
######3.get the rotation matrix###########
Nx=M_unit[0]
Ny=M_unit[1]
Nz=M_unit[2]
PQ_rot=np.array([[Nx*Nx*(1-theta_cos)+theta_cos, Nx*Ny*(1-theta_cos)+Nz*theta_sin, Nx*Nz*(1-theta_cos)-Ny*theta_sin],
[Nx*Ny*(1-theta_cos)-Nz*theta_sin, Ny*Ny*(1-theta_cos)+theta_cos, Ny*Nz*(1-theta_cos)+Nx*theta_sin],
[Nx*Nz*(1-theta_cos)+Ny*theta_sin, Ny*Nz*(1-theta_cos)-Nx*theta_sin, Nz*Nz*(1-theta_cos)+theta_cos]])
###### #####
a_PQ_rot=np.dot(pos_array,PQ_rot) #three basis vector after rotation
a_PQ_rot=a_PQ_rot.tolist()
L_rot=np.dot(L,PQ_rot)
############## the second rotation begin##############
######1.get the angel between two vectors########
L_norm=(L_rot[0]**2+L_rot[1]**2+L_rot[2]**2)**0.5 #the norm of vetor before roation
K_norm=(K[0]**2+K[1]**2+K[2]**2)**0.5 #the norm of vetor after roation
LK_dot=np.dot(L_rot,K)
theta=math.acos(LK_dot/(L_norm*K_norm))##obtain theta, the unit is radian instead of degree
theta_cos=LK_dot/(L_norm*K_norm)
theta_sin=math.sin(theta)
######2.get the rotation axis##############
H=np.array([L_rot[1]*K[2]-L_rot[2]*K[1], L_rot[2]*K[0]-L_rot[0]*K[2], L_rot[0]*K[1]-L_rot[1]*K[0]])
H_norm=(H[0]**2+H[1]**2+H[2]**2)**0.5 #the norm of M vetor
H_unit=np.array([H[0]/H_norm, H[1]/H_norm, H[2]/H_norm])
######3.get the rotation matrix###########
Ex=H_unit[0]
Ey=H_unit[1]
Ez=H_unit[2]
LK_rot=np.array([[Ex*Ex*(1-theta_cos)+theta_cos, Ex*Ey*(1-theta_cos)+Ez*theta_sin, Ex*Ez*(1-theta_cos)-Ey*theta_sin],
[Ex*Ey*(1-theta_cos)-Ez*theta_sin, Ey*Ey*(1-theta_cos)+theta_cos, Ey*Ez*(1-theta_cos)+Ex*theta_sin],
[Ex*Ez*(1-theta_cos)+Ey*theta_sin, Ey*Nz*(1-theta_cos)-Ex*theta_sin, Ez*Ez*(1-theta_cos)+theta_cos]])
###### #####
a_LK_rot=np.dot(a_PQ_rot,LK_rot) #three basis vector after rotation
a_LK_rot=a_LK_rot.tolist()
os.system("cp POSCAR POSCAR_original") #copy original POSCAR
r=[]
with open ("POSCAR") as poscar1:
for line in poscar1:
r.append(line)
f=open("POSCAR_rota","w") #write POSCAR after rotation as POSCAR_rota
for i in range(0,2):
f.write(r[i])
for j in range(len(a_LK_rot)):
f.write(str(a_LK_rot[j][0])+' ')
f.write(str(a_LK_rot[j][1])+' ')
f.write(str(a_LK_rot[j][2]))
f.write('\n')
for x in range(5,len(r)):
f.write(r[x])
f.close()
os.system("cp POSCAR_rota POSCAR") ## copy POSCAR_rota as POSCAR
###### Thirdly,apply tensile strain to the rotated basis vector
def postrain(poscar):
t2=[]
t3=[]
with open (poscar) as poscar2:
pos2=poscar2.readlines()
length=len(pos2)
for i in range(2,5):
j=pos2[i]
j=j.split()
t2.extend(j)
for i in range(len(t2)):
t3.extend([float(t2[i])])
pos_array3=np.array(t3).reshape((3,3))
if (Q0==np.array([1, 0, 0])).all():
stra_matr=np.array([[1,0,stra],
[0,1,0],
[stra,0,1]]) # strain(xz) and strain(zx)
a_stra=np.dot(pos_array3,stra_matr)
with open (poscar) as poscar:
s=[]
for line in poscar:
s.append(line)
f=open("POSCAR_stra","w")
for i in range(0,2):
f.write(s[i])
for j in range(len(a_stra)):
f.write(str(a_stra[j][0])+' ')
f.write(str(a_stra[j][1])+' ')
f.write(str(a_stra[j][2]))
f.write('\n')
for x in range(5,len(s)):
f.write(s[x])
f.close()
###### Fourthly, performing VASP calculation
for i in np.arange(stra,stra*(times+1),stra):
|
print("****************************")
i=round(i,2)
print(i)
postrain("POSCAR")
os.system("cp POSCAR_stra POSCAR")
os.system("cp POSCAR_stra POSCAR_"+str(i))####
#os.system("bsub < Job_qsh.sh")
os.system("srun -n 20 /scratch/jin.zhang3_397857/Software/vasp.5.4.4/bin/vasp_std > vasp.out")
chek=os.popen("grep Voluntary OUTCAR").read()
while "Voluntary" not in chek:
chek=os.popen("grep Voluntary OUTCAR").read()
if "Voluntary" in chek:
break
os.system("cp OUTCAR OUTCAR_"+str(i))####
os.system("cp CONTCAR CONTCAR_"+str(i))####
os.system("grep 'in kB' OUTCAR > kB")
fin=os.popen("tail -1 kB").read()
fin=fin.split()
#os.system("cp CONTCAR POSCAR")
#os.system("bsub < Job_qsh.sh")
|
conditional_block
|
|
shear_calculation_withoutplot_vasp.py
|
1 -2 \n").split()]
if len(Sh_dir)==3:
Sh_dir=Sh_dir
elif len(Sh_pla)==4:
U=Sh_dir[1]+2*Sh_dir[0]
V=Sh_dir[0]+2*Sh_dir[1]
W=Sh_dir[3]
UVW_gcd=gcd(gcd(U,V),W)
Sh_dir=np.array([U/UVW_gcd, V/UVW_gcd, W/UVW_gcd])
L0=Sh_dir
K0=np.array([0, 0, 1]) #after rotation. K0 is the z axis. Since the x axis will not be optimized as we set in VASP, so Q0 is [1, 0, 0]
#P0=np.array([1, 1, 1]) #provide the axis before rotation.. P0 is the tensile direction we want to calculate.
###finish to read the input file
#Q0=np.array([1, 0, 0]) #after rotation. Q0 is the x axis. Since the x axis will not be optimized as we set in VASP, so Q0 is [1, 0, 0]
#------------------------------------------------------------------------------------
###open POSCAR
t=[]
t1=[]
with open ("POSCAR") as poscar0:
pos0=poscar0.readlines()
length=len(pos0)
for i in range(2,5):
j=pos0[i]
j=j.split()
t.extend(j)
print(t)
for i in range(len(t)):
t1.extend([float(t[i])])
pos_array=np.array(t1).reshape((3,3)) ####read basis vector from POSCAR
print(pos_array)
oa=np.array([pos_array[0][0], pos_array[0][1], pos_array[0][2]])
ob=np.array([pos_array[1][0], pos_array[1][1], pos_array[1][2]])
oc=np.array([pos_array[2][0], pos_array[2][1], pos_array[2][2]])
#------------------------------------------------------------------------------------
###start to calculate the structure data before rotation######
##a1_len=(float(pos_array[0][0])**2+float(pos_array[0][1])**2+float(pos_array[0][2])**2)**0.5
##a2_len=(float(pos_array[1][0])**2+float(pos_array[1][1])**2+float(pos_array[1][2])**2)**0.5
##a3_len=(float(pos_array[2][0])**2+float(pos_array[2][1])**2+float(pos_array[2][2])**2)**0.5
##
##P=np.array([P0[0]*a1_len,P0[1]*a2_len,P0[2]*a3_len])
##Q=np.array([Q0[0]*a1_len,Q0[1]*a2_len,Q0[2]*a3_len])
##
##XYZ_a=np.array([[a1_len, 0, 0],
## [0, a2_len, 0],
## [0, 0, a3_len]])
#----------------------------------------
basis=np.array([oa, ob, oc])
P0_abc=np.array([[P0[0], 0, 0],
[0, P0[1], 0],
[0, 0, P0[2]]])
P0_abc_basis=np.dot(P0_abc,basis)
P=P0_abc_basis[0]+P0_abc_basis[1]+P0_abc_basis[2] # the position of the normal of shear plane before rotation
Q0_abc=np.array([[Q0[0], 0, 0],
[0, Q0[1], 0],
[0, 0, Q0[2]]])
Q0_abc_basis=np.dot(Q0_abc,basis)
Q=Q0_abc_basis[0]+Q0_abc_basis[1]+Q0_abc_basis[2] # the position of the normal of shear plane after rotation
#----------------------------------------
#basis=np.array([oa, ob, oc])
L0_abc=np.array([[L0[0], 0, 0],
[0, L0[1], 0],
[0, 0, L0[2]]])
L0_abc_basis=np.dot(L0_abc,basis)
L=L0_abc_basis[0]+L0_abc_basis[1]+L0_abc_basis[2] # the position of shear direction before rotation
K0_abc=np.array([[K0[0], 0, 0],
[0, K0[1], 0],
[0, 0, K0[2]]])
K0_abc_basis=np.dot(K0_abc,basis)
K=K0_abc_basis[0]+K0_abc_basis[1]+K0_abc_basis[2] # the position of shear direction after rotation
#------------------------------------------------------------------------------------
###start to calculate the structure data after rotation######
############## the first rotation begin##############
######1.get the angel between two vectors########
P_norm=(P[0]**2+P[1]**2+P[2]**2)**0.5 #the norm of vetor before roation
Q_norm=(Q[0]**2+Q[1]**2+Q[2]**2)**0.5 #the norm of vetor after roation
PQ_dot=np.dot(P,Q)
theta=math.acos(PQ_dot/(P_norm*Q_norm))##obtain theta, the unit is radian instead of degree
theta_cos=PQ_dot/(P_norm*Q_norm)
theta_sin=math.sin(theta)
######2.get the rotation axis##############
M=np.array([P[1]*Q[2]-P[2]*Q[1], P[2]*Q[0]-P[0]*Q[2], P[0]*Q[1]-P[1]*Q[0]])
M_norm=(M[0]**2+M[1]**2+M[2]**2)**0.5 #the norm of M vetor
M_unit=np.array([M[0]/M_norm, M[1]/M_norm, M[2]/M_norm])
######3.get the rotation matrix###########
Nx=M_unit[0]
Ny=M_unit[1]
Nz=M_unit[2]
PQ_rot=np.array([[Nx*Nx*(1-theta_cos)+theta_cos, Nx*Ny*(1-theta_cos)+Nz*theta_sin, Nx*Nz*(1-theta_cos)-Ny*theta_sin],
[Nx*Ny*(1-theta_cos)-Nz*theta_sin, Ny*Ny*(1-theta_cos)+theta_cos, Ny*Nz*(1-theta_cos)+Nx*theta_sin],
[Nx*Nz*(1-theta_cos)+Ny*theta_sin, Ny*Nz*(1-theta_cos)-Nx*theta_sin, Nz*Nz*(1-theta_cos)+theta_cos]])
###### #####
a_PQ_rot=np.dot(pos_array,PQ_rot) #three basis vector after rotation
a_PQ_rot=a_PQ_rot.tolist()
L_rot=np.dot(L,PQ_rot)
############## the second rotation begin##############
######1.get the angel between two vectors########
L_norm=(L_rot[0]**2+L_rot[1]**2+L_rot[2]**2)**0.5 #the norm of vetor before roation
K_norm=(K[0]**2+K[1]**2+K[2]**2)**0.5 #the norm of vetor after roation
LK_dot=np.dot(L_rot,K)
theta=math.acos(LK_dot/(L_norm*K_norm))##obtain theta, the unit is radian instead of degree
theta_cos=LK_dot/(L_norm*K_norm)
theta_sin=math.sin(theta)
######2.get the rotation axis##############
H=np.array([L_rot[1]*K[2]-L_rot[2]*K[1], L_rot[2]*K[0]-L_rot[0]*K[2], L_rot[0]*K[1]-L_rot[1]*K[0]])
H_norm=(H[0]**2+H[1]**2+H[2]**2)**0.5 #the norm of M vetor
H_unit=np.array([H[0]/H_norm, H[1]/H_norm, H[2]/H_norm])
######3.get the rotation matrix###########
Ex=H_unit[0]
Ey=H_unit[1]
Ez=H_unit[2]
LK_rot=np.array([[Ex*Ex*(1-theta_cos)+theta_cos, Ex*Ey*(1-theta_cos)+Ez*theta_sin, Ex*Ez*(1-theta_cos)-Ey*theta_sin],
[Ex*Ey*(1-theta_cos)-Ez*theta_sin, Ey*Ey*(1-theta_cos)+theta_cos, Ey*Ez*(1-theta_cos)+Ex*theta_sin],
[Ex*Ez*(1-theta_cos)+Ey*theta_sin, Ey*Nz*(1-theta_cos)-Ex*theta_sin, Ez*Ez*(1-theta_cos)+theta_cos]])
###### #####
a_LK_rot=np.dot(a_PQ_rot,LK_rot) #three basis vector after rotation
a_LK_rot=a_LK_rot.tolist()
|
os.system("cp POSCAR POSCAR_original") #copy original POSCAR
r=[]
with open ("POSCAR") as poscar1:
|
random_line_split
|
|
lib.rs
|
Balance;
pub Locks get(fn locks): map T::AccountId => Vec<BalanceLock<T::Balance, T::Moment>>;
}
add_extra_genesis {
config(balances): Vec<(T::AccountId, T::Balance)>;
config(vesting): Vec<(T::AccountId, T::BlockNumber, T::BlockNumber, T::Balance)>;
// ^^ begin, length, amount liquid at genesis
}
}
decl_module! {
pub struct Module<T: Trait> for enum Call where origin: T::Origin {
fn deposit_event() = default;
/// Transfer some liquid free balance to another account.
///
/// `transfer` will set the `FreeBalance` of the sender and receiver.
/// It will decrease the total issuance of the system by the `TransferFee`.
/// If the sender's account is below the existential deposit as a result
/// of the transfer, the account will be reaped.
///
/// The dispatch origin for this call must be `Signed` by the transactor.
///
/// # <weight>
/// - Dependent on arguments but not critical, given proper implementations for
/// input config types. See related functions below.
/// - It contains a limited number of reads and writes internally and no complex computation.
///
/// Related functions:
///
/// - `ensure_can_withdraw` is always called internally but has a bounded complexity.
/// - Transferring balances to accounts that did not exist before will cause
/// `T::OnNewAccount::on_new_account` to be called.
/// - Removing enough funds from an account will trigger
/// `T::DustRemoval::on_unbalanced` and `T::OnFreeBalanceZero::on_free_balance_zero`.
/// - `transfer_keep_alive` works the same way as `transfer`, but has an additional
/// check that the transfer will not kill the origin account.
///
/// # </weight>
#[weight = SimpleDispatchInfo::FixedNormal(1_000_000)]
pub fn transfer(
origin,
dest: <T::Lookup as StaticLookup>::Source,
#[compact] value: T::Balance
) {
let transactor = ensure_signed(origin)?;
let dest = T::Lookup::lookup(dest)?;
<Self as Currency<_>>::transfer(&transactor, &dest, value, ExistenceRequirement::AllowDeath)?;
}
/// Set the balances of a given account.
///
/// This will alter `FreeBalance` and `ReservedBalance` in storage. it will
/// also decrease the total issuance of the system (`TotalIssuance`).
/// If the new free or reserved balance is below the existential deposit,
/// it will reset the account nonce (`system::AccountNonce`).
///
/// The dispatch origin for this call is `root`.
///
/// # <weight>
/// - Independent of the arguments.
/// - Contains a limited number of reads and writes.
/// # </weight>
#[weight = SimpleDispatchInfo::FixedOperational(50_000)]
fn set_balance(
origin,
who: <T::Lookup as StaticLookup>::Source,
#[compact] new_free: T::Balance,
#[compact] new_reserved: T::Balance
) {
ensure_root(origin)?;
let who = T::Lookup::lookup(who)?;
let current_free = <FreeBalance<T>>::get(&who);
if new_free > current_free {
mem::drop(PositiveImbalance::<T>::new(new_free - current_free));
} else if new_free < current_free {
mem::drop(NegativeImbalance::<T>::new(current_free - new_free));
}
Self::set_free_balance(&who, new_free);
let current_reserved = <ReservedBalance<T>>::get(&who);
if new_reserved > current_reserved {
mem::drop(PositiveImbalance::<T>::new(new_reserved - current_reserved));
} else if new_reserved < current_reserved {
mem::drop(NegativeImbalance::<T>::new(current_reserved - new_reserved));
}
Self::set_reserved_balance(&who, new_reserved);
}
/// Exactly as `transfer`, except the origin must be root and the source account may be
/// specified.
#[weight = SimpleDispatchInfo::FixedNormal(1_000_000)]
pub fn force_transfer(
origin,
source: <T::Lookup as StaticLookup>::Source,
dest: <T::Lookup as StaticLookup>::Source,
#[compact] value: T::Balance
) {
ensure_root(origin)?;
let source = T::Lookup::lookup(source)?;
let dest = T::Lookup::lookup(dest)?;
<Self as Currency<_>>::transfer(&source, &dest, value, ExistenceRequirement::AllowDeath)?;
}
}
}
impl<T: Trait> Module<T> {
// PUBLIC IMMUTABLES
/// Get the amount that is currently being vested and cannot be transferred out of this account.
pub fn vesting_balance(who: &T::AccountId) -> T::Balance {
if let Some(v) = Self::vesting(who) {
Self::free_balance(who).min(v.locked_at(<system::Module<T>>::block_number()))
} else {
Zero::zero()
}
}
// PRIVATE MUTABLES
/// Set the reserved balance of an account to some new value. Will enforce `ExistentialDeposit`
/// law, annulling the account as needed.
///
/// Doesn't do any preparatory work for creating a new account, so should only be used when it
/// is known that the account already exists.
///
/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
/// the caller will do this.
fn set_reserved_balance(who: &T::AccountId, balance: T::Balance) -> UpdateBalanceOutcome {
<ReservedBalance<T>>::insert(who, balance);
UpdateBalanceOutcome::Updated
}
/// Set the free balance of an account to some new value. Will enforce `ExistentialDeposit`
/// law, annulling the account as needed.
///
/// Doesn't do any preparatory work for creating a new account, so should only be used when it
/// is known that the account already exists.
///
/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
/// the caller will do this.
fn set_free_balance(who: &T::AccountId, balance: T::Balance) -> UpdateBalanceOutcome {
// Commented out for now - but consider it instructive.
// assert!(!Self::total_balance(who).is_zero());
<FreeBalance<T>>::insert(who, balance);
UpdateBalanceOutcome::Updated
}
}
// wrapping these imbalances in a private module is necessary to ensure absolute privacy
// of the inner member.
mod imbalances {
use rstd::mem;
use crate::{result, Imbalance, Saturating, StorageValue, Trait, Zero};
/// Opaque, move-only struct with private fields that serves as a token denoting that
/// funds have been created without any equal and opposite accounting.
#[must_use]
pub struct PositiveImbalance<T: Trait>(T::Balance);
impl<T: Trait> PositiveImbalance<T> {
/// Create a new positive imbalance from a balance.
pub fn new(amount: T::Balance) -> Self {
PositiveImbalance(amount)
}
}
/// Opaque, move-only struct with private fields that serves as a token denoting that
/// funds have been destroyed without any equal and opposite accounting.
#[must_use]
pub struct
|
<T: Trait>(T::Balance);
impl<T: Trait> NegativeImbalance<T> {
/// Create a new negative imbalance from a balance.
pub fn new(amount: T::Balance) -> Self {
NegativeImbalance(amount)
}
}
impl<T: Trait> Imbalance<T::Balance> for PositiveImbalance<T> {
type Opposite = NegativeImbalance<T>;
fn zero() -> Self {
Self(Zero::zero())
}
fn drop_zero(self) -> result::Result<(), Self> {
if self.0.is_zero() {
Ok(())
} else {
Err(self)
}
}
fn split(self, amount: T::Balance) -> (Self, Self) {
let first = self.0.min(amount);
let second = self.0 - first;
mem::forget(self);
(Self(first), Self(second))
}
fn merge(mut self, other: Self) -> Self {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
self
}
fn subsume(&mut self, other: Self) {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
}
fn offset(self, other: Self::Opposite) -> result::Result<Self, Self::Opposite
|
NegativeImbalance
|
identifier_name
|
lib.rs
|
but has an additional
/// check that the transfer will not kill the origin account.
///
/// # </weight>
#[weight = SimpleDispatchInfo::FixedNormal(1_000_000)]
pub fn transfer(
origin,
dest: <T::Lookup as StaticLookup>::Source,
#[compact] value: T::Balance
) {
let transactor = ensure_signed(origin)?;
let dest = T::Lookup::lookup(dest)?;
<Self as Currency<_>>::transfer(&transactor, &dest, value, ExistenceRequirement::AllowDeath)?;
}
/// Set the balances of a given account.
///
/// This will alter `FreeBalance` and `ReservedBalance` in storage. it will
/// also decrease the total issuance of the system (`TotalIssuance`).
/// If the new free or reserved balance is below the existential deposit,
/// it will reset the account nonce (`system::AccountNonce`).
///
/// The dispatch origin for this call is `root`.
///
/// # <weight>
/// - Independent of the arguments.
/// - Contains a limited number of reads and writes.
/// # </weight>
#[weight = SimpleDispatchInfo::FixedOperational(50_000)]
fn set_balance(
origin,
who: <T::Lookup as StaticLookup>::Source,
#[compact] new_free: T::Balance,
#[compact] new_reserved: T::Balance
) {
ensure_root(origin)?;
let who = T::Lookup::lookup(who)?;
let current_free = <FreeBalance<T>>::get(&who);
if new_free > current_free {
mem::drop(PositiveImbalance::<T>::new(new_free - current_free));
} else if new_free < current_free {
mem::drop(NegativeImbalance::<T>::new(current_free - new_free));
}
Self::set_free_balance(&who, new_free);
let current_reserved = <ReservedBalance<T>>::get(&who);
if new_reserved > current_reserved {
mem::drop(PositiveImbalance::<T>::new(new_reserved - current_reserved));
} else if new_reserved < current_reserved {
mem::drop(NegativeImbalance::<T>::new(current_reserved - new_reserved));
}
Self::set_reserved_balance(&who, new_reserved);
}
/// Exactly as `transfer`, except the origin must be root and the source account may be
/// specified.
#[weight = SimpleDispatchInfo::FixedNormal(1_000_000)]
pub fn force_transfer(
origin,
source: <T::Lookup as StaticLookup>::Source,
dest: <T::Lookup as StaticLookup>::Source,
#[compact] value: T::Balance
) {
ensure_root(origin)?;
let source = T::Lookup::lookup(source)?;
let dest = T::Lookup::lookup(dest)?;
<Self as Currency<_>>::transfer(&source, &dest, value, ExistenceRequirement::AllowDeath)?;
}
}
}
impl<T: Trait> Module<T> {
// PUBLIC IMMUTABLES
/// Get the amount that is currently being vested and cannot be transferred out of this account.
pub fn vesting_balance(who: &T::AccountId) -> T::Balance {
if let Some(v) = Self::vesting(who) {
Self::free_balance(who).min(v.locked_at(<system::Module<T>>::block_number()))
} else {
Zero::zero()
}
}
// PRIVATE MUTABLES
/// Set the reserved balance of an account to some new value. Will enforce `ExistentialDeposit`
/// law, annulling the account as needed.
///
/// Doesn't do any preparatory work for creating a new account, so should only be used when it
/// is known that the account already exists.
///
/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
/// the caller will do this.
fn set_reserved_balance(who: &T::AccountId, balance: T::Balance) -> UpdateBalanceOutcome {
<ReservedBalance<T>>::insert(who, balance);
UpdateBalanceOutcome::Updated
}
/// Set the free balance of an account to some new value. Will enforce `ExistentialDeposit`
/// law, annulling the account as needed.
///
/// Doesn't do any preparatory work for creating a new account, so should only be used when it
/// is known that the account already exists.
///
/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
/// the caller will do this.
fn set_free_balance(who: &T::AccountId, balance: T::Balance) -> UpdateBalanceOutcome {
// Commented out for now - but consider it instructive.
// assert!(!Self::total_balance(who).is_zero());
<FreeBalance<T>>::insert(who, balance);
UpdateBalanceOutcome::Updated
}
}
// wrapping these imbalances in a private module is necessary to ensure absolute privacy
// of the inner member.
mod imbalances {
use rstd::mem;
use crate::{result, Imbalance, Saturating, StorageValue, Trait, Zero};
/// Opaque, move-only struct with private fields that serves as a token denoting that
/// funds have been created without any equal and opposite accounting.
#[must_use]
pub struct PositiveImbalance<T: Trait>(T::Balance);
impl<T: Trait> PositiveImbalance<T> {
/// Create a new positive imbalance from a balance.
pub fn new(amount: T::Balance) -> Self {
PositiveImbalance(amount)
}
}
/// Opaque, move-only struct with private fields that serves as a token denoting that
/// funds have been destroyed without any equal and opposite accounting.
#[must_use]
pub struct NegativeImbalance<T: Trait>(T::Balance);
impl<T: Trait> NegativeImbalance<T> {
/// Create a new negative imbalance from a balance.
pub fn new(amount: T::Balance) -> Self {
NegativeImbalance(amount)
}
}
impl<T: Trait> Imbalance<T::Balance> for PositiveImbalance<T> {
type Opposite = NegativeImbalance<T>;
fn zero() -> Self {
Self(Zero::zero())
}
fn drop_zero(self) -> result::Result<(), Self> {
if self.0.is_zero() {
Ok(())
} else {
Err(self)
}
}
fn split(self, amount: T::Balance) -> (Self, Self) {
let first = self.0.min(amount);
let second = self.0 - first;
mem::forget(self);
(Self(first), Self(second))
}
fn merge(mut self, other: Self) -> Self {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
self
}
fn subsume(&mut self, other: Self) {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
}
fn offset(self, other: Self::Opposite) -> result::Result<Self, Self::Opposite> {
let (a, b) = (self.0, other.0);
mem::forget((self, other));
if a >= b {
Ok(Self(a - b))
} else {
Err(NegativeImbalance::new(b - a))
}
}
fn peek(&self) -> T::Balance {
self.0
}
}
impl<T: Trait> Imbalance<T::Balance> for NegativeImbalance<T> {
type Opposite = PositiveImbalance<T>;
fn zero() -> Self {
Self(Zero::zero())
}
fn drop_zero(self) -> result::Result<(), Self> {
if self.0.is_zero() {
Ok(())
} else {
Err(self)
}
}
fn split(self, amount: T::Balance) -> (Self, Self) {
let first = self.0.min(amount);
let second = self.0 - first;
mem::forget(self);
(Self(first), Self(second))
}
fn merge(mut self, other: Self) -> Self {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
self
}
fn subsume(&mut self, other: Self) {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
}
fn offset(self, other: Self::Opposite) -> result::Result<Self, Self::Opposite> {
let (a, b) = (self.0, other.0);
mem::forget((self, other));
if a >= b {
Ok(Self(a - b))
} else {
Err(PositiveImbalance::new(b - a))
}
}
fn peek(&self) -> T::Balance {
self.0
}
}
|
random_line_split
|
||
lib.rs
|
{
mem::drop(NegativeImbalance::<T>::new(current_reserved - new_reserved));
}
Self::set_reserved_balance(&who, new_reserved);
}
/// Exactly as `transfer`, except the origin must be root and the source account may be
/// specified.
#[weight = SimpleDispatchInfo::FixedNormal(1_000_000)]
pub fn force_transfer(
origin,
source: <T::Lookup as StaticLookup>::Source,
dest: <T::Lookup as StaticLookup>::Source,
#[compact] value: T::Balance
) {
ensure_root(origin)?;
let source = T::Lookup::lookup(source)?;
let dest = T::Lookup::lookup(dest)?;
<Self as Currency<_>>::transfer(&source, &dest, value, ExistenceRequirement::AllowDeath)?;
}
}
}
impl<T: Trait> Module<T> {
// PUBLIC IMMUTABLES
/// Get the amount that is currently being vested and cannot be transferred out of this account.
pub fn vesting_balance(who: &T::AccountId) -> T::Balance {
if let Some(v) = Self::vesting(who) {
Self::free_balance(who).min(v.locked_at(<system::Module<T>>::block_number()))
} else {
Zero::zero()
}
}
// PRIVATE MUTABLES
/// Set the reserved balance of an account to some new value. Will enforce `ExistentialDeposit`
/// law, annulling the account as needed.
///
/// Doesn't do any preparatory work for creating a new account, so should only be used when it
/// is known that the account already exists.
///
/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
/// the caller will do this.
fn set_reserved_balance(who: &T::AccountId, balance: T::Balance) -> UpdateBalanceOutcome {
<ReservedBalance<T>>::insert(who, balance);
UpdateBalanceOutcome::Updated
}
/// Set the free balance of an account to some new value. Will enforce `ExistentialDeposit`
/// law, annulling the account as needed.
///
/// Doesn't do any preparatory work for creating a new account, so should only be used when it
/// is known that the account already exists.
///
/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
/// the caller will do this.
fn set_free_balance(who: &T::AccountId, balance: T::Balance) -> UpdateBalanceOutcome {
// Commented out for now - but consider it instructive.
// assert!(!Self::total_balance(who).is_zero());
<FreeBalance<T>>::insert(who, balance);
UpdateBalanceOutcome::Updated
}
}
// wrapping these imbalances in a private module is necessary to ensure absolute privacy
// of the inner member.
mod imbalances {
use rstd::mem;
use crate::{result, Imbalance, Saturating, StorageValue, Trait, Zero};
/// Opaque, move-only struct with private fields that serves as a token denoting that
/// funds have been created without any equal and opposite accounting.
#[must_use]
pub struct PositiveImbalance<T: Trait>(T::Balance);
impl<T: Trait> PositiveImbalance<T> {
/// Create a new positive imbalance from a balance.
pub fn new(amount: T::Balance) -> Self {
PositiveImbalance(amount)
}
}
/// Opaque, move-only struct with private fields that serves as a token denoting that
/// funds have been destroyed without any equal and opposite accounting.
#[must_use]
pub struct NegativeImbalance<T: Trait>(T::Balance);
impl<T: Trait> NegativeImbalance<T> {
/// Create a new negative imbalance from a balance.
pub fn new(amount: T::Balance) -> Self {
NegativeImbalance(amount)
}
}
impl<T: Trait> Imbalance<T::Balance> for PositiveImbalance<T> {
type Opposite = NegativeImbalance<T>;
fn zero() -> Self {
Self(Zero::zero())
}
fn drop_zero(self) -> result::Result<(), Self> {
if self.0.is_zero() {
Ok(())
} else {
Err(self)
}
}
fn split(self, amount: T::Balance) -> (Self, Self) {
let first = self.0.min(amount);
let second = self.0 - first;
mem::forget(self);
(Self(first), Self(second))
}
fn merge(mut self, other: Self) -> Self {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
self
}
fn subsume(&mut self, other: Self) {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
}
fn offset(self, other: Self::Opposite) -> result::Result<Self, Self::Opposite> {
let (a, b) = (self.0, other.0);
mem::forget((self, other));
if a >= b {
Ok(Self(a - b))
} else {
Err(NegativeImbalance::new(b - a))
}
}
fn peek(&self) -> T::Balance {
self.0
}
}
impl<T: Trait> Imbalance<T::Balance> for NegativeImbalance<T> {
type Opposite = PositiveImbalance<T>;
fn zero() -> Self {
Self(Zero::zero())
}
fn drop_zero(self) -> result::Result<(), Self> {
if self.0.is_zero() {
Ok(())
} else {
Err(self)
}
}
fn split(self, amount: T::Balance) -> (Self, Self) {
let first = self.0.min(amount);
let second = self.0 - first;
mem::forget(self);
(Self(first), Self(second))
}
fn merge(mut self, other: Self) -> Self {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
self
}
fn subsume(&mut self, other: Self) {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
}
fn offset(self, other: Self::Opposite) -> result::Result<Self, Self::Opposite> {
let (a, b) = (self.0, other.0);
mem::forget((self, other));
if a >= b {
Ok(Self(a - b))
} else {
Err(PositiveImbalance::new(b - a))
}
}
fn peek(&self) -> T::Balance {
self.0
}
}
impl<T: Trait> Drop for PositiveImbalance<T> {
/// Basic drop handler will just square up the total issuance.
fn drop(&mut self) {
<super::TotalIssuance<T>>::mutate(|v| *v = v.saturating_add(self.0));
}
}
impl<T: Trait> Drop for NegativeImbalance<T> {
/// Basic drop handler will just square up the total issuance.
fn drop(&mut self) {
<super::TotalIssuance<T>>::mutate(|v| *v = v.saturating_sub(self.0));
}
}
}
impl<T: Trait> Currency<T::AccountId> for Module<T>
where
T::Balance: MaybeSerializeDeserialize + Debug,
{
type Balance = T::Balance;
type PositiveImbalance = PositiveImbalance<T>;
type NegativeImbalance = NegativeImbalance<T>;
fn total_balance(who: &T::AccountId) -> Self::Balance {
Self::free_balance(who) + Self::reserved_balance(who)
}
fn can_slash(who: &T::AccountId, value: Self::Balance) -> bool {
Self::free_balance(who) >= value
}
fn total_issuance() -> Self::Balance {
<TotalIssuance<T>>::get()
}
fn minimum_balance() -> Self::Balance {
Zero::zero()
}
fn burn(mut amount: Self::Balance) -> Self::PositiveImbalance {
<TotalIssuance<T>>::mutate(|issued| {
*issued = issued.checked_sub(&amount).unwrap_or_else(|| {
amount = *issued;
Zero::zero()
});
});
PositiveImbalance::new(amount)
}
fn issue(mut amount: Self::Balance) -> Self::NegativeImbalance {
<TotalIssuance<T>>::mutate(|issued| {
*issued = issued.checked_add(&amount).unwrap_or_else(|| {
amount = Self::Balance::max_value() - *issued;
Self::Balance::max_value()
})
});
NegativeImbalance::new(amount)
}
fn free_balance(who: &T::AccountId) -> Self::Balance
|
{
<FreeBalance<T>>::get(who)
}
|
identifier_body
|
|
lib.rs
|
;
pub Locks get(fn locks): map T::AccountId => Vec<BalanceLock<T::Balance, T::Moment>>;
}
add_extra_genesis {
config(balances): Vec<(T::AccountId, T::Balance)>;
config(vesting): Vec<(T::AccountId, T::BlockNumber, T::BlockNumber, T::Balance)>;
// ^^ begin, length, amount liquid at genesis
}
}
decl_module! {
pub struct Module<T: Trait> for enum Call where origin: T::Origin {
fn deposit_event() = default;
/// Transfer some liquid free balance to another account.
///
/// `transfer` will set the `FreeBalance` of the sender and receiver.
/// It will decrease the total issuance of the system by the `TransferFee`.
/// If the sender's account is below the existential deposit as a result
/// of the transfer, the account will be reaped.
///
/// The dispatch origin for this call must be `Signed` by the transactor.
///
/// # <weight>
/// - Dependent on arguments but not critical, given proper implementations for
/// input config types. See related functions below.
/// - It contains a limited number of reads and writes internally and no complex computation.
///
/// Related functions:
///
/// - `ensure_can_withdraw` is always called internally but has a bounded complexity.
/// - Transferring balances to accounts that did not exist before will cause
/// `T::OnNewAccount::on_new_account` to be called.
/// - Removing enough funds from an account will trigger
/// `T::DustRemoval::on_unbalanced` and `T::OnFreeBalanceZero::on_free_balance_zero`.
/// - `transfer_keep_alive` works the same way as `transfer`, but has an additional
/// check that the transfer will not kill the origin account.
///
/// # </weight>
#[weight = SimpleDispatchInfo::FixedNormal(1_000_000)]
pub fn transfer(
origin,
dest: <T::Lookup as StaticLookup>::Source,
#[compact] value: T::Balance
) {
let transactor = ensure_signed(origin)?;
let dest = T::Lookup::lookup(dest)?;
<Self as Currency<_>>::transfer(&transactor, &dest, value, ExistenceRequirement::AllowDeath)?;
}
/// Set the balances of a given account.
///
/// This will alter `FreeBalance` and `ReservedBalance` in storage. it will
/// also decrease the total issuance of the system (`TotalIssuance`).
/// If the new free or reserved balance is below the existential deposit,
/// it will reset the account nonce (`system::AccountNonce`).
///
/// The dispatch origin for this call is `root`.
///
/// # <weight>
/// - Independent of the arguments.
/// - Contains a limited number of reads and writes.
/// # </weight>
#[weight = SimpleDispatchInfo::FixedOperational(50_000)]
fn set_balance(
origin,
who: <T::Lookup as StaticLookup>::Source,
#[compact] new_free: T::Balance,
#[compact] new_reserved: T::Balance
) {
ensure_root(origin)?;
let who = T::Lookup::lookup(who)?;
let current_free = <FreeBalance<T>>::get(&who);
if new_free > current_free {
mem::drop(PositiveImbalance::<T>::new(new_free - current_free));
} else if new_free < current_free {
mem::drop(NegativeImbalance::<T>::new(current_free - new_free));
}
Self::set_free_balance(&who, new_free);
let current_reserved = <ReservedBalance<T>>::get(&who);
if new_reserved > current_reserved {
mem::drop(PositiveImbalance::<T>::new(new_reserved - current_reserved));
} else if new_reserved < current_reserved {
mem::drop(NegativeImbalance::<T>::new(current_reserved - new_reserved));
}
Self::set_reserved_balance(&who, new_reserved);
}
/// Exactly as `transfer`, except the origin must be root and the source account may be
/// specified.
#[weight = SimpleDispatchInfo::FixedNormal(1_000_000)]
pub fn force_transfer(
origin,
source: <T::Lookup as StaticLookup>::Source,
dest: <T::Lookup as StaticLookup>::Source,
#[compact] value: T::Balance
) {
ensure_root(origin)?;
let source = T::Lookup::lookup(source)?;
let dest = T::Lookup::lookup(dest)?;
<Self as Currency<_>>::transfer(&source, &dest, value, ExistenceRequirement::AllowDeath)?;
}
}
}
impl<T: Trait> Module<T> {
// PUBLIC IMMUTABLES
/// Get the amount that is currently being vested and cannot be transferred out of this account.
pub fn vesting_balance(who: &T::AccountId) -> T::Balance {
if let Some(v) = Self::vesting(who) {
Self::free_balance(who).min(v.locked_at(<system::Module<T>>::block_number()))
} else {
Zero::zero()
}
}
// PRIVATE MUTABLES
/// Set the reserved balance of an account to some new value. Will enforce `ExistentialDeposit`
/// law, annulling the account as needed.
///
/// Doesn't do any preparatory work for creating a new account, so should only be used when it
/// is known that the account already exists.
///
/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
/// the caller will do this.
fn set_reserved_balance(who: &T::AccountId, balance: T::Balance) -> UpdateBalanceOutcome {
<ReservedBalance<T>>::insert(who, balance);
UpdateBalanceOutcome::Updated
}
/// Set the free balance of an account to some new value. Will enforce `ExistentialDeposit`
/// law, annulling the account as needed.
///
/// Doesn't do any preparatory work for creating a new account, so should only be used when it
/// is known that the account already exists.
///
/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
/// the caller will do this.
fn set_free_balance(who: &T::AccountId, balance: T::Balance) -> UpdateBalanceOutcome {
// Commented out for now - but consider it instructive.
// assert!(!Self::total_balance(who).is_zero());
<FreeBalance<T>>::insert(who, balance);
UpdateBalanceOutcome::Updated
}
}
// wrapping these imbalances in a private module is necessary to ensure absolute privacy
// of the inner member.
mod imbalances {
use rstd::mem;
use crate::{result, Imbalance, Saturating, StorageValue, Trait, Zero};
/// Opaque, move-only struct with private fields that serves as a token denoting that
/// funds have been created without any equal and opposite accounting.
#[must_use]
pub struct PositiveImbalance<T: Trait>(T::Balance);
impl<T: Trait> PositiveImbalance<T> {
/// Create a new positive imbalance from a balance.
pub fn new(amount: T::Balance) -> Self {
PositiveImbalance(amount)
}
}
/// Opaque, move-only struct with private fields that serves as a token denoting that
/// funds have been destroyed without any equal and opposite accounting.
#[must_use]
pub struct NegativeImbalance<T: Trait>(T::Balance);
impl<T: Trait> NegativeImbalance<T> {
/// Create a new negative imbalance from a balance.
pub fn new(amount: T::Balance) -> Self {
NegativeImbalance(amount)
}
}
impl<T: Trait> Imbalance<T::Balance> for PositiveImbalance<T> {
type Opposite = NegativeImbalance<T>;
fn zero() -> Self {
Self(Zero::zero())
}
fn drop_zero(self) -> result::Result<(), Self> {
if self.0.is_zero() {
Ok(())
} else
|
}
fn split(self, amount: T::Balance) -> (Self, Self) {
let first = self.0.min(amount);
let second = self.0 - first;
mem::forget(self);
(Self(first), Self(second))
}
fn merge(mut self, other: Self) -> Self {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
self
}
fn subsume(&mut self, other: Self) {
self.0 = self.0.saturating_add(other.0);
mem::forget(other);
}
fn offset(self, other: Self::Opposite) -> result::Result<Self, Self::Opposite
|
{
Err(self)
}
|
conditional_block
|
query.py
|
链路是否主备线路，0表示备线路，1表示主线路
"over_drop", ##overlay非云网链路丢包率
"over_dropth", ##overlay非云网链路丢包率阈值
"over_sl_drop", ##overlay云网链路丢包率
"over_sl_dropth", ##overlay云网链路丢包率阈值
"over_delay", ##overlay链路时延
"over_shakedelay", ##overlay链路抖动
"over_mindelay",
"over_maxdelay",
"over_mdev",
"under_drop", ##underlay非云网链路丢包率
"under_dropth", ##underlay非云网链路丢包率阈值
"under_sl_drop", ##underlay云网链路丢包率
"under_sl_dropth", ##underlay云网链路丢包率阈值
"under_delay", ##underlay链路时延
"under_shakedelay", ##underlay链路抖动
"under_mindelay",
"under_maxdelay",
"under_mdev",
"tags",
#"metricset_name"
]
key2index = {k : i for i, k in enumerate(keys)}
def request_data(sess, postdata):
postdata = json.dumps(postdata)
response = sess.post(url, data=postdata)
res = response.text
data = json.loads(res)
samples = []
for i, a in enumerate(data['hits']['hits']):
pairs = a['_source']['pairs']
pair_dict = defaultdict(str)
pair_dict['timestamp'] = datetime.datetime.fromtimestamp(float(a['_source']['timestamp'])/1000)
if len(a['_source']['tags']) > 0:
pair_dict['tags'] = a['_source']['tags'][0]['value']
if len(a['_source']['tags']) > 1:
print('Warning:', a['_source']['tags'])
pair_dict['metricset_name'] = a['_source']['metricset']['name']
for p in pairs:
pair_dict[p['name']] = list(p['value'].values())[0]
samples.append([pair_dict[key] for key in keys])
return sorted(samples, key=lambda x:x[0]), data['hits']['total']
def get_list():
postdata = json.loads(json_query)
del postdata['query']['bool']['filter'][3:]
timestamp_range = postdata['query']['bool']['filter'][2]['range']['timestamp']
ta = datetime.datetime.now() - datetime.timedelta(hours=1)
tb = ta + datetime.timedelta(minutes=2)
timestamp_range['gte'] = ta.timestamp()*1000
timestamp_range['lt'] = tb.timestamp()*1000
logging.info('Request data in [{}, {})'.format(ta, tb))
sess = requests.Session()
sess.headers.update(headers)
for _ in range(3):
try:
samples, tot = request_data(sess, postdata)
logging.info('Hists: {} / {}'.format(len(samples), tot))
break
except Exception as e:
logging.warning(e)
logging.info('Retry')
time.sleep(3)
df = pd.DataFrame(samples, columns=keys)
tunoip = {}
proname = {}
for nsid in df['ns_id'].unique():
if nsid=='': continue
t = df[df.ns_id==nsid]
tunoip[nsid] = sorted(list(t.tun_oip.unique()))
proname[nsid] = t.pop_proname.iloc[-1]
return tunoip, proname
def query(nsid, tunoip, begin_time=None, end_time=None, data_dir='./data'):
""" Query the ping data of specifical ns_id and tun_oip between specifical time range.
Time is datetime type or a string with format '%Y-%m-%d %H:%M:%S', e.g. '2019-10-13 10:09:00'
nsid: ns_id value.
tunoip: tun_oip value.
begin_time: The begining time to query. Default None means the time before 30 days.
end_time: The ending time to query. Default None means the current time.
"""
if type(begin_time) is str: begin_time = datetime.datetime.fromisoformat(begin_time)
if type(end_time) is str: end_time = datetime.datetime.fromisoformat(end_time)
nowtime = datetime.datetime.now()
pretime = nowtime - datetime.timedelta(days=30)
if end_time is None: end_time = nowtime
if begin_time is None: begin_time = pretime
q_begin_time, q_end_time = begin_time, end_time
if not os.path.exists(data_dir): os.mkdir(data_dir)
nsid_dir = os.path.join(data_dir, nsid)
if not os.path.exists(nsid_dir): os.mkdir(nsid_dir)
file_prefix = tunoip.replace('>', '')
# timestamp_path = os.path.join(nsid_dir, '%s.ts'%file_prefix)
csv_path = os.path.join(nsid_dir, '%s.csv'%file_prefix)
logging.info('Query: nsid={}, tunoip={}, timerange=[{}, {})'.format(nsid, tunoip, begin_time, end_time))
if os.path.exists(csv_path):
logging.info('Read data from %s'%csv_path)
df = pd.read_csv(csv_path)
logging.info('Time range: [{}, {}]'.format(df.iloc[0]['timestamp'], df.iloc[-1]['timestamp']))
begin_time = datetime.datetime.fromisoformat(df.iloc[-1]['timestamp']) + datetime.timedelta(minutes=1)
if begin_time < pretime:
begin_time = pretime
df.index = pd.to_datetime(df['timestamp'])
p_num = len(df)
if df.index[0] < pretime:
df = df.loc[pretime:]
logging.info('Forget %d records'%(p_num-len(df)))
else:
df = pd.DataFrame(columns=keys)
begin_time = pretime
# if nowtime - end_time < datetime.timedelta(hours=1):
# tmp_end_time = end_time - datetime.timedelta(hours=1)
# else:
# tmp_end_time = end_time
tmp_end_time = end_time
if q_end_time < begin_time:
df = df.loc[q_begin_time:q_end_time]
logging.info('Query: {} items'.format(len(df)))
logging.info('done.')
return
s = json_query.replace('$nsid', nsid).replace('$tunoip', tunoip)
postdata = json.loads(s)
timestamp_range = postdata['query']['bool']['filter'][2]['range']['timestamp']
t_begin_time, t_end_time = int(begin_time.timestamp()), int(end_time.timestamp())
t_tmp_end_time = int(tmp_end_time.timestamp())
postdata['size'] = 10000
delta_time = 3600*24*3 # 7 days
sess = requests.Session()
sess.headers.update(headers)
def get_data(t, et):
if t >= et: return []
timestamp_range['gte'] = t*1000
timestamp_range['lt'] = et*1000
logging.info('Request data in [{}, {})'.format(datetime.datetime.fromtimestamp(t), datetime.datetime.fromtimestamp(et)))
for _ in range(5):
try:
samples, tot = request_data(sess, postdata)
logging.info('Hists: {} / {}'.format(len(samples), tot))
return samples
except Exception as e:
logging.warning(e)
logging.info('Retry')
time.sleep(3)
data = []
for t in range(t_begin_time, t_tmp_end_time, delta_time):
et = min(t+delta_time, t_tmp_end_time)
data.extend(get_data(t, et))
df = df.append(pd.DataFrame(data, columns=keys), ignore_index=True)
# samples = get_data(t_tmp_end_time, t_end_time)
logging.info('Total Hists: {}'.format(len(data)))
if len(data)>0:
logging.info('Save data to %s'%csv_path)
df.to_csv(csv_path, index=False)
# df = df.append(pd.DataFrame(samples, columns=keys), ignore_index=True)
df.index = pd.to_datetime(df['timestamp'])
df = df.loc[q_begin_time:q_end_time]
logging.info('Query: {} items'.format(len(df)))
logging.info('done.')
df.fillna(0, inplace=True)
return df
def cache():
tunoip, proname = get_list()
nsids = ['500850', '504608', '502902']
for nsid in nsids:
for lk in tunoip[nsid]:
query(nsid, lk, data_dir='/home/monitor/data')
# data_dir = '/home/monitor/data'
# fn = os.path.join(data_dir, 'collect.log')
fn = '/dev/stdout'
logging.basicConfig(level=logging.INFO,
format='[%(asctime)s] %(levelname)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
|
random_line_split
|
||
query.py
|
filter": [
{"term": {"pairs.name": "tun_oip"}},
{"term": {"pairs.value.string": "$tunoip"}}
]
}
}
}
}
]
}
},
"size": 10000
}
'''
url = 'http://rpc.dsp.chinanetcenter.com:10200/api/console/proxy?path=*metricelf*%2F_search&method=POST'
headers = {
'Content-Type': 'application/json; charset=utf-8',
'Cookie': '__lcl=zh_CN; cluster=dashboard',
'DNT': '1',
'Host': 'rpc.dsp.chinanetcenter.com:10200',
'kbn-version': '6.1.1',
'Origin': 'http://rpc.dsp.chinanetcenter.com:10200',
'Referer': 'http://rpc.dsp.chinanetcenter.com:10200/app/kibana',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.108 Safari/537.36',
}
keys = [
"timestamp",
"pop_proname", ##项目名称
"pop_proid", ##oms上项目ID
"ns_id", ##项目的enterpriseID
"tun_uip", ##underlay链路ip
"tun_oip", ##overlay链路ip
"pop_ip", ##POP服务器管理ip
"tun_cost", ##链路权重
"tun_status", ##链路状态，0表示正常，1表示异常
"tun_cost_status", ##链路是否主备线路，0表示备线路，1表示主线路
"over_drop", ##overlay非云网链路丢包率
"over_dropth", ##overlay非云网链路丢包率阈值
"over_sl_drop", ##overlay云网链路丢包率
"over_sl_dropth", ##overlay云网链路丢包率阈值
"over_delay", ##overlay链路时延
"over_shakedelay", ##overlay链路抖动
"over_mindelay",
"over_maxdelay",
"over_mdev",
"under_drop", ##underlay非云网链路丢包率
"under_dropth", ##underlay非云网链路丢包率阈值
"under_sl_drop", ##underlay云网链路丢包率
"under_sl_dropth", ##underlay云网链路丢包率阈值
"under_delay", ##underlay链路时延
"under_shakedelay", ##underlay链路抖动
"under_mindelay",
"under_maxdelay",
"under_mdev",
"tags",
#"metricset_name"
]
key2index = {k : i for i, k in enumerate(keys)}
def request_data(sess, postdata):
postdata = json.dumps(postdata)
response = sess.post(url, data=postdata)
res = response.text
data = json.loads(res)
samples = []
for i, a in enumerate(data['hits']['hits']):
pairs = a['_source']['pairs']
pair_dict = defaultdict(str)
pair_dict['timestamp'] = datetime.datetime.fromtimestamp(float(a['_source']['timestamp'])/1000)
if len(a['_source']['tags']) > 0:
pair_dict['tags'] = a['_source']['tags'][0]['value']
if len(a['_source']['tags']) > 1:
print('Warning:', a['_source']['tags'])
pair_dict['metricset_name'] = a['_source']['metricset']['name']
for p in pairs:
pair_dict[p['name']] = list(p['value'].values())[0]
samples.append([pair_dict[key] for key in keys])
return sorted(samples, key=lambda x:x[0]), data['hits']['total']
def get_list():
postdata = json.loads(json_query)
del postdata['query']['bool']['filter'][3:]
timestamp_range = postdata['query']['bool']['filter'][2]['range']['timestamp']
ta = datetime.datetime.now() - datetime.timedelta(hours=1)
tb = ta + datetime.timedelta(minutes=2)
timestamp_range['gte'] = ta.timestamp()*1000
timestamp_range['lt'] = tb.timestamp()*1000
logging.info('Request data in [{}, {})'.format(ta, tb))
sess = requests.Session()
sess.headers.update(headers)
for _ in range(3):
try:
samples, tot = request_data(sess, postdata)
logging.info('Hists: {} / {}'.format(len(samples), tot))
break
except Exception as e:
logging.warning(e)
logging.info('Retry')
time.sleep(3)
df = pd.DataFrame(samples, columns=keys)
tunoip = {}
proname = {}
for nsid in df['ns_id'].unique():
if nsid=='': continue
t = df[df.ns_id==nsid]
tunoip[nsid] = sorted(list(t.tun_oip.unique()))
proname[nsid] = t.pop_proname.iloc[-1]
return tunoip, proname
def query(nsid, tunoip, begin_time=None, end_time=None, data_dir='./data'):
""" Query the ping data of specifical ns_id and tun_oip between specifical time range.
Time is datetime type or a string with format '%Y-%m-%d %H:%M:%S', e.g. '2019-10-13 10:09:00'
nsid: ns_id value.
tunoip: tun_oip value.
begin_time: The begining time to query. Default None means the time before 30 days.
end_time: The ending time to query. Default None means the current time.
"""
if type(begin_time) is str: begin_time = datetime.datetime.fromisoformat(begin_time)
if type(end_time) is str: end_time = datetime.datetime.fromisoformat(end_time)
nowtime = datetime.datetime.now()
pretime = nowtime - datetime.timedelta(days=30)
if end_time is None: end_time = nowtime
if begin_time is None: begin_time = pretime
q_begin_time, q_end_time = begin_time, end_time
if not os.path.exists(data_dir): os.mkdir(data_dir)
nsid_dir = os.path.join(data_dir, nsid)
if not os.path.exists(nsid_dir): os.mkdir(nsid_dir)
file_prefix = tunoip.replace('>', '')
# timestamp_path = os.path.join(nsid_dir, '%s.ts'%file_prefix)
csv_path = os.path.join(nsid_dir, '%s.csv'%file_prefix)
logging.info('Query: nsid={}, tunoip={}, timerange=[{}, {})'.format(nsid, tunoip, begin_t
|
if os.path.exists(csv_path):
logging.info('Read data from %s'%csv_path)
df = pd.read_csv(csv_path)
logging.info('Time range: [{}, {}]'.format(df.iloc[0]['timestamp'], df.iloc[-1]['timestamp']))
begin_time = datetime.datetime.fromisoformat(df.iloc[-1]['timestamp']) + datetime.timedelta(minutes=1)
if begin_time < pretime:
begin_time = pretime
df.index = pd.to_datetime(df['timestamp'])
p_num = len(df)
if df.index[0] < pretime:
df = df.loc[pretime:]
logging.info('Forget %d records'%(p_num-len(df)))
else:
df = pd.DataFrame(columns=keys)
begin_time = pretime
# if nowtime - end_time < datetime.timedelta(hours=1):
# tmp_end_time = end_time - datetime.timedelta(hours=1)
# else:
# tmp_end_time = end_time
tmp_end_time = end_time
if q_end_time < begin_time:
df = df.loc[q_begin_time:q_end_time]
logging.info('Query: {} items'.format(len(df)))
logging.info('done.')
return
s = json_query.replace('$nsid', nsid).replace('$tunoip', tunoip)
postdata = json.loads(s)
timestamp_range = postdata['query']['bool']['filter'][2]['range']['timestamp']
t_begin_time, t_end_time = int(begin_time.timestamp()), int(end_time.timestamp())
t_tmp_end_time = int(tmp_end_time.timestamp())
postdata['size'] = 10000
delta_time = 3600*24*3 # 7 days
sess = requests.Session()
sess.headers.update(headers)
def get_data(t, et):
if t >= et: return []
timestamp_range['gte'] = t*1000
timestamp_range['lt'] = et*1000
logging.info('Request data in [{}, {})'.format(datetime.datetime
|
ime, end_time))
|
conditional_block
|
query.py
|
备线路，1表示主线路
"over_drop", ##overlay非云网链路丢包率
"over_dropth", ##overlay非云网链路丢包率阈值
"over_sl_drop", ##overlay云网链路丢包率
"over_sl_dropth", ##overlay云网链路丢包率阈值
"over_delay", ##overlay链路时延
"over_shakedelay", ##overlay链路抖动
"over_mindelay",
"over_maxdelay",
"over_mdev",
"under_drop", ##underlay非云网链路丢包率
"under_dropth", ##underlay非云网链路丢包率阈值
"under_sl_drop", ##underlay云网链路丢包率
"under_sl_dropth", ##underlay云网链路丢包率阈值
"under_delay", ##underlay链路时延
"under_shakedelay", ##underlay链路抖动
"under_mindelay",
"under_maxdelay",
"under_mdev",
"tags",
#"metricset_name"
]
key2index = {k : i for i, k in enumerate(keys)}
def request_data(sess, postdata):
postdata = json.dumps(postdata)
response = sess.post(url, data=postdata)
res = response.text
data = json.loads(res)
samples = []
for i, a in enumerate(data['hits']['hits']):
pairs = a['_source']['pairs']
pair_dict = defaultdict(str)
pair_dict['timestamp'] = datetime.datetime.fromtimestamp(float(a['_source']['timestamp'])/1000)
if len(a['_source']['tags']) > 0:
pair_dict['tags'] = a['_source']['tags'][0]['value']
if len(a['_source']['tags']) > 1:
print('Warning:', a['_source']['tags'])
pair_dict['metricset_name'] = a['_source']['metricset']['name']
for p in pairs:
pair_dict[p['name']] = list(p['value'].values())[0]
samples.append([pair_dict[key] for key in keys])
return sorted(samples, key=lambda x:x[0]), data['hits']['total']
def get_list():
postdata = json.loads(json_query)
del postdata['query']['bool']['filter'][3:]
timestamp_range = postdata['query']['bool']['filter'][2]['range']['timestamp']
ta = datetime.datetime.now() - datetime.timedelta(hours=1)
tb = ta + datetime.timedelta(minutes=2)
timestamp_range['gte'] = ta.timestamp()*1000
timestamp_range['lt'] = tb.timestamp()*1000
logging.info('Request data in [{}, {})'.format(ta, tb))
sess = requests.Session()
sess.headers.update(headers)
for _ in range(3):
try:
samples, tot = request_data(sess, postdata)
logging.info('Hists: {} / {}'.format(len(samples), tot))
break
except Exception as e:
logging.warning(e)
logging.info('Retry')
time.sleep(3)
df = pd.DataFrame(samples, columns=keys)
tunoip = {}
proname = {}
for nsid in df['ns_id'].unique():
if nsid=='': continue
t = df[df.ns_id==nsid]
tunoip[nsid] = sorted(list(t.tun_oip.unique()))
proname[nsid] = t.pop_proname.iloc[-1]
return tunoip, proname
def query(nsid, tunoip, begin_time=None, end_time=None, data_dir='./data'):
""" Query the ping data of specifical ns_id and tun_oip between specifical time range.
Time is datetime type or a string with format '%Y-%m-%d %H:%M:%S', e.g. '2019-10-13 10:09:00'
nsid: ns_id value.
tunoip: tun_oip value.
begin_time: The begining time to query. Default None means the time before 30 days.
end_time: The ending time to query. Default None means the current time.
"""
if type(begin_time) is str: begin_time = datetime.datetime.fromisoformat(begin_time)
if type(end_time) is str: end_time = datetime.datetime.fromisoformat(end_time)
nowtime = datetime.datetime.now()
pretime = nowtime - datetime.timedelta(days=30)
if end_time is None: end_time = nowtime
if begin_time is None: begin_time = pretime
q_begin_time, q_end_time = begin_time, end_time
if not os.path.exists(data_dir): os.mkdir(data_dir)
nsid_dir = os.path.join(data_dir, nsid)
if not os.path.exists(nsid_dir): os.mkdir(nsid_dir)
file_prefix = tunoip.replace('>', '')
# timestamp_path = os.path.join(nsid_dir, '%s.ts'%file_prefix)
csv_path = os.path.join(nsid_dir, '%s.csv'%file_prefix)
logging.info('Query: nsid={}, tunoip={}, timerange=[{}, {})'.format(nsid, tunoip, begin_time, end_time))
if os.path.exists(csv_path):
logging.info('Read data from %s'%csv_path)
df = pd.read_csv(csv_path)
logging.info('Time range: [{}, {}]'.format(df.iloc[0]['timestamp'], df.iloc[-1]['timestamp']))
begin_time = datetime.datetime.fromisoformat(df.iloc[-1]['timestamp']) + datetime.timedelta(minutes=1)
if begin_time < pretime:
begin_time = pretime
df.index = pd.to_datetime(df['timestamp'])
p_num = len(df)
if df.index[0] < pretime:
df = df.loc[pretime:]
logging.info('Forget %d records'%(p_num-len(df)))
else:
df = pd.DataFrame(columns=keys)
begin_time = pretime
# if nowtime - end_time < datetime.timedelta(hours=1):
# tmp_end_time = end_time - datetime.timedelta(hours=1)
# else:
# tmp_end_time = end_time
tmp_end_time = end_time
if q_end_time < begin_time:
df = df.loc[q_begin_time:q_end_time]
logging.info('Query: {} items'.format(len(df)))
logging.info('done.')
return
s = json_query.replace('$nsid', nsid).replace('$tunoip', tunoip)
postdata = json.loads(s)
timestamp_range = postdata['query']['bool']['filter'][2]['range']['timestamp']
t_begin_time, t_end_time = int(begin_time.timestamp()), int(end_time.timestamp())
t_tmp_end_time = int(tmp_end_time.timestamp())
postdata['size'] = 10000
delta_time = 3600*24*3 # 7 days
sess = requests.Session()
sess.headers.update(headers)
def get_data(t, et):
if t >= et: return []
timestamp_range['gte'] = t*1000
timestamp_range['lt'] = et*1000
logging.info('Request data in [{}, {})'.format(datetime.datetime.fromtimestamp(t), datetime.datetime.fromtimestamp(et)))
for _ in range(5):
try:
samples, tot = request_data(sess, postdata)
logging.info('Hists: {} / {}'.format(len(samples), tot))
return samples
except Exception as e:
logging.warning(e)
logging.info('Retry')
time.sleep(3)
data = []
for t in range(t_begin_time, t_tmp_end_time, delta_time):
et = min(t+delta_time, t_tmp_end_time)
data.extend(get_data(t, et))
df = df.append(pd.DataFrame(data, columns=keys), ignore_index=True)
# samples = get_data(t_tmp_end_time, t_end_time)
logging.info('Total Hists: {}'.format(len(data)))
if len(data)>0:
logging.info('Save data to %s'%csv_path)
df.to_csv(csv_path, index=False)
# df = df.append(pd.DataFrame(samples, columns=keys), ignore_index=True)
df.index = pd.to_datetime(df['timestamp'])
df = df.loc[q_begin_time:q_end_time]
logging.info('Query: {} items'.format(len(df)))
logging.info('done.')
df.fillna(0, inplace=True)
return df
def cache():
tunoip, proname = get_list()
nsids = ['500850', '504608', '502902']
for nsid in nsids:
for lk in tunoip[nsid]:
query(nsid, lk, data_dir='/home/monitor/data')
# data_dir = '/home/monitor/data'
# fn = os.path.join(data_dir, 'collect.log')
fn = '/dev/stdou
|
t'
logging.basicConfig(level=logging.INFO,
format='[%(asctime)s] %(levelname)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
if __name__ == "__main__":
|
identifier_body
|
|
query.py
|
filter": [
{"term": {"pairs.name": "tun_oip"}},
{"term": {"pairs.value.string": "$tunoip"}}
]
}
}
}
}
]
}
},
"size": 10000
}
'''
url = 'http://rpc.dsp.chinanetcenter.com:10200/api/console/proxy?path=*metricelf*%2F_search&method=POST'
headers = {
'Content-Type': 'application/json; charset=utf-8',
'Cookie': '__lcl=zh_CN; cluster=dashboard',
'DNT': '1',
'Host': 'rpc.dsp.chinanetcenter.com:10200',
'kbn-version': '6.1.1',
'Origin': 'http://rpc.dsp.chinanetcenter.com:10200',
'Referer': 'http://rpc.dsp.chinanetcenter.com:10200/app/kibana',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.108 Safari/537.36',
}
keys = [
"timestamp",
"pop_proname", ##项目名称
"pop_proid", ##oms上项目ID
"ns_id", ##项目的enterpriseID
"tun_uip", ##underlay链路ip
"tun_oip", ##overlay链路ip
"pop_ip", ##POP服务器管理ip
"tun_cost", ##链路权重
"tun_status", ##链路状态，0表示正常，1表示异常
"tun_cost_status", ##链路是否主备线路，0表示备线路，1表示主线路
"over_drop", ##overlay非云网链路丢包率
"over_dropth", ##overlay非云网链路丢包率阈值
"over_sl_drop", ##overlay云网链路丢包率
"over_sl_dropth", ##overlay云网链路丢包率阈值
"over_delay", ##overlay链路时延
"over_shakedelay", ##overlay链路抖动
"over_mindelay",
"over_maxdelay",
"over_mdev",
"under_drop", ##underlay非云网链路丢包率
"under_dropth", ##underlay非云网链路丢包率阈值
"under_sl_drop", ##underlay云网链路丢包率
"under_sl_dropth", ##underlay云网链路丢包率阈值
"under_delay", ##underlay链路时延
"under_shakedelay", ##underlay链路抖动
"under_mindelay",
"under_maxdelay",
"under_mdev",
"tags",
#"metricset_name"
]
key2index = {k : i for i, k in enumerate(keys)}
def request_data(sess, postdata):
postdata = json.dumps(postdata)
response = sess.post(url, data=postdata)
res = response.text
data = json.loads(res)
samples = []
for i, a in enumerate(data['hits']['hits']):
pairs = a['_source']['pairs']
|
defaultdict(str)
pair_dict['timestamp'] = datetime.datetime.fromtimestamp(float(a['_source']['timestamp'])/1000)
if len(a['_source']['tags']) > 0:
pair_dict['tags'] = a['_source']['tags'][0]['value']
if len(a['_source']['tags']) > 1:
print('Warning:', a['_source']['tags'])
pair_dict['metricset_name'] = a['_source']['metricset']['name']
for p in pairs:
pair_dict[p['name']] = list(p['value'].values())[0]
samples.append([pair_dict[key] for key in keys])
return sorted(samples, key=lambda x:x[0]), data['hits']['total']
def get_list():
postdata = json.loads(json_query)
del postdata['query']['bool']['filter'][3:]
timestamp_range = postdata['query']['bool']['filter'][2]['range']['timestamp']
ta = datetime.datetime.now() - datetime.timedelta(hours=1)
tb = ta + datetime.timedelta(minutes=2)
timestamp_range['gte'] = ta.timestamp()*1000
timestamp_range['lt'] = tb.timestamp()*1000
logging.info('Request data in [{}, {})'.format(ta, tb))
sess = requests.Session()
sess.headers.update(headers)
for _ in range(3):
try:
samples, tot = request_data(sess, postdata)
logging.info('Hists: {} / {}'.format(len(samples), tot))
break
except Exception as e:
logging.warning(e)
logging.info('Retry')
time.sleep(3)
df = pd.DataFrame(samples, columns=keys)
tunoip = {}
proname = {}
for nsid in df['ns_id'].unique():
if nsid=='': continue
t = df[df.ns_id==nsid]
tunoip[nsid] = sorted(list(t.tun_oip.unique()))
proname[nsid] = t.pop_proname.iloc[-1]
return tunoip, proname
def query(nsid, tunoip, begin_time=None, end_time=None, data_dir='./data'):
""" Query the ping data of specifical ns_id and tun_oip between specifical time range.
Time is datetime type or a string with format '%Y-%m-%d %H:%M:%S', e.g. '2019-10-13 10:09:00'
nsid: ns_id value.
tunoip: tun_oip value.
begin_time: The begining time to query. Default None means the time before 30 days.
end_time: The ending time to query. Default None means the current time.
"""
if type(begin_time) is str: begin_time = datetime.datetime.fromisoformat(begin_time)
if type(end_time) is str: end_time = datetime.datetime.fromisoformat(end_time)
nowtime = datetime.datetime.now()
pretime = nowtime - datetime.timedelta(days=30)
if end_time is None: end_time = nowtime
if begin_time is None: begin_time = pretime
q_begin_time, q_end_time = begin_time, end_time
if not os.path.exists(data_dir): os.mkdir(data_dir)
nsid_dir = os.path.join(data_dir, nsid)
if not os.path.exists(nsid_dir): os.mkdir(nsid_dir)
file_prefix = tunoip.replace('>', '')
# timestamp_path = os.path.join(nsid_dir, '%s.ts'%file_prefix)
csv_path = os.path.join(nsid_dir, '%s.csv'%file_prefix)
logging.info('Query: nsid={}, tunoip={}, timerange=[{}, {})'.format(nsid, tunoip, begin_time, end_time))
if os.path.exists(csv_path):
logging.info('Read data from %s'%csv_path)
df = pd.read_csv(csv_path)
logging.info('Time range: [{}, {}]'.format(df.iloc[0]['timestamp'], df.iloc[-1]['timestamp']))
begin_time = datetime.datetime.fromisoformat(df.iloc[-1]['timestamp']) + datetime.timedelta(minutes=1)
if begin_time < pretime:
begin_time = pretime
df.index = pd.to_datetime(df['timestamp'])
p_num = len(df)
if df.index[0] < pretime:
df = df.loc[pretime:]
logging.info('Forget %d records'%(p_num-len(df)))
else:
df = pd.DataFrame(columns=keys)
begin_time = pretime
# if nowtime - end_time < datetime.timedelta(hours=1):
# tmp_end_time = end_time - datetime.timedelta(hours=1)
# else:
# tmp_end_time = end_time
tmp_end_time = end_time
if q_end_time < begin_time:
df = df.loc[q_begin_time:q_end_time]
logging.info('Query: {} items'.format(len(df)))
logging.info('done.')
return
s = json_query.replace('$nsid', nsid).replace('$tunoip', tunoip)
postdata = json.loads(s)
timestamp_range = postdata['query']['bool']['filter'][2]['range']['timestamp']
t_begin_time, t_end_time = int(begin_time.timestamp()), int(end_time.timestamp())
t_tmp_end_time = int(tmp_end_time.timestamp())
postdata['size'] = 10000
delta_time = 3600*24*3 # 7 days
sess = requests.Session()
sess.headers.update(headers)
def get_data(t, et):
if t >= et: return []
timestamp_range['gte'] = t*1000
timestamp_range['lt'] = et*1000
logging.info('Request data in [{}, {})'.format(datetime.datetime
|
pair_dict =
|
identifier_name
|
day.page.ts
|
items = [];
total = [];
day = new Date().toString();
start = new Date().setHours(0, 0, 0, 0).toString();
end = new Date().setHours(23, 59, 59, 999).toString();
i = 0;
currency = '';
pdfObj = null;
company = '';
displaystart = '';
displayend = '';
a = 0;
salesvalue = 0;
min = '2020';
max = '';
constructor(
private router: Router,
private syncService: SyncService,
private loadingCtrl: LoadingController,
private datePipe: DatePipe,
private datepicker: DatePicker,
private plt: Platform,
private socialSharing: SocialSharing,
private file: File,
private fileOpener: FileOpener,
private storage: Storage,
private databaseservice: DatabaseService
)
|
this.displayend = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy');
this.start = first1;
this.end = last1;
// alert('start: ' + this.start + '\n' + this.end);
this.getData();
}
ngOnInit() {
}
share() {
// this.getData();
this.createPdf();
}
back() {
this.router.navigate(['/menu/reports']);
}
onActivate(event) {
if (event.type === 'click') {
console.log(event.row);
}
}
async getData() {
let loading = await this.loadingCtrl.create();
await loading.present();
let now = new Date().toString();
const a = this.datePipe.transform(now, 'dd MMM yyyy h:mm a');
let start = new Date().setHours(0, 0, 0, 0).toString();
const b = this.datePipe.transform(start, 'dd MMM yyyy h:mm a');
// alert('start:' + this.start + '\ncurrent:' + this.end);
// alert('day:' + this.day)
this.syncService.getTodaysSales(this.start, this.end, this.currency).then((data) => {
this.total = data;
console.log(data);
for (let i = 0; i < this.total.length; i++) {
const data1 = {
day: this.total[i].Date,
sales: this.total[i].Total,
paid: this.total[i].Paid
};
this.data.push(data1);
}
this.data = [...this.data];
loading.dismiss();
// alert('y' + this.total[0].Total + 'p' + this.total[0].Paid);
});
}
selectDate() {
var options={
date: new Date(),
mode: 'date',
androidTheme: this.datepicker.ANDROID_THEMES.THEME_DEVICE_DEFAULT_LIGHT
};
this.datepicker.show(options).then((date) => {
this.day = this.datePipe.transform(date, 'dd MMM yyyy h:mm a');
this.data = [];
this.getData();
// console.log('selected:',this.myDate);
});
}
changeDate() {
//alert('yes' + this.data.length);
//alert('y' + this.start);
if ( this.i === 2 || (this.a === 0 && this.i === this.salesvalue)) {
this.i = 0;
this.a = 1;
const firstdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth(), 1).setHours(0, 0, 0, 0);
const first1 = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy h:mm a');
const lastdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth() + 1, 0).setHours(23, 59, 59, 999);
const last1 = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy h:mm a');
this.displaystart = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy');
this.displayend = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy');
// const s = new Date(this.day).setHours(0, 0, 0, 0).toString();
// const l = new Date(this.day).setHours(23, 59, 59, 999).toString();
this.start = first1;
this.end = last1;
// this.start = this.datePipe.transform(s, 'dd MMM yyyy h:mm a');
// this.end = this.datePipe.transform(l, 'dd MMM yyyy h:mm a');
// alert('s: ' + first1 + '\nL: ' + last1 );
this.data = [];
this.getData();
}
this.i = this.i + 1;
this.day = this.datePipe.transform(this.day, 'dd MMM yyyy h:mm a');
}
async createPdf() {
let a ;
let x ;
let y ;
let z ;
let left;
let right;
let items = [];
let loading = await this.loadingCtrl.create();
await loading.present();
const itemss = [];
for (let i = 0; i < this.data.length; i++) {
itemss.push(
[
{ text: this.data[i].day.toString() , fontSize: 18, color: '#000000' },
{ text: this.data[i].sales.toString() , fontSize: 18, color: '#000000' },
{ text: this.data[i].paid.toString(), fontSize: 18, color: '#000000' }
]
);
}
left = {
text: [
{ text: this.company, bold: true, fontSize: 20, alignment: 'left'},
]
};
right = {
text: [
{ text: this.datePipe.transform(new Date(), 'dd MMM yyyy') , color: '#000000' , fontSize: 18, alignment: 'right'},
]
};
var docDefinition = {
pageSize: 'A4',
pageMargins: [ 20, 20, 20, 20 ],
content: [
{ text: 'SALES BY DAY', bold: true, alignment: 'center', fontSize: 25, style: 'subheader'},
{ text: this.displaystart + ' - ' + this.displayend, bold: true, alignment: 'center', fontSize: 20, style: 'subheader'},
// { margin: [0, 10, 0, 0],
// text: 'CUSTOMER STATEMENT', style: 'header', fontSize: 25, alignment: 'left', color: '#ff0000' },
{
margin: [0, 10, 0, 0],
canvas:
[
{
type: 'line',
x1: 0, y1: 0,
x2: 555, y2: 0,
lineWidth: 3
},
]
},
{
margin: [0, 5, 0, 0],
style: 'totalsTable',
table: {
widths: [ 300, 250 ],
body: [
[
left, right
],
],
},
layout: 'noBorders'
},
{
margin: [0, 20, 0, 0],
text: [
{ text: 'Client ' , style: 'subheader', bold: true, fontSize: 20, color: '#000000' },
{ text: ' Total' , style: 'subheader', bold: true, fontSize: 20, color: '#000000' },
{ text: ' Paid' , style: 'subheader', bold: true
|
{
const last = new Date(new Date().getFullYear(), 11, 31);
this.max = this.datePipe.transform(last, 'yyyy');
this.storage.get('COM').then((val) => {
this.company = val;
});
storage.get('currency').then((val) => {
if (val !== null) {
this.currency = val.toString();
debugger
}
});
this.salesvalue = this.databaseservice.getSalesByDayValue();
this.day = this.datePipe.transform(this.day, 'MMM yyyy h:mm a');
const firstdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth(), 1).setHours(0, 0, 0, 0);
const first1 = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy h:mm a');
const lastdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth() + 1, 0).setHours(23, 59, 59, 999);
const last1 = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy h:mm a');
this.displaystart = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy');
|
identifier_body
|
day.page.ts
|
'\n' + this.end);
this.getData();
}
ngOnInit() {
}
share() {
// this.getData();
this.createPdf();
}
back() {
this.router.navigate(['/menu/reports']);
}
onActivate(event) {
if (event.type === 'click') {
console.log(event.row);
}
}
async getData() {
let loading = await this.loadingCtrl.create();
await loading.present();
let now = new Date().toString();
const a = this.datePipe.transform(now, 'dd MMM yyyy h:mm a');
let start = new Date().setHours(0, 0, 0, 0).toString();
const b = this.datePipe.transform(start, 'dd MMM yyyy h:mm a');
// alert('start:' + this.start + '\ncurrent:' + this.end);
// alert('day:' + this.day)
this.syncService.getTodaysSales(this.start, this.end, this.currency).then((data) => {
this.total = data;
console.log(data);
for (let i = 0; i < this.total.length; i++) {
const data1 = {
day: this.total[i].Date,
sales: this.total[i].Total,
paid: this.total[i].Paid
};
this.data.push(data1);
}
this.data = [...this.data];
loading.dismiss();
// alert('y' + this.total[0].Total + 'p' + this.total[0].Paid);
});
}
selectDate() {
var options={
date: new Date(),
mode: 'date',
androidTheme: this.datepicker.ANDROID_THEMES.THEME_DEVICE_DEFAULT_LIGHT
};
this.datepicker.show(options).then((date) => {
this.day = this.datePipe.transform(date, 'dd MMM yyyy h:mm a');
this.data = [];
this.getData();
// console.log('selected:',this.myDate);
});
}
changeDate() {
//alert('yes' + this.data.length);
//alert('y' + this.start);
if ( this.i === 2 || (this.a === 0 && this.i === this.salesvalue)) {
this.i = 0;
this.a = 1;
const firstdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth(), 1).setHours(0, 0, 0, 0);
const first1 = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy h:mm a');
const lastdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth() + 1, 0).setHours(23, 59, 59, 999);
const last1 = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy h:mm a');
this.displaystart = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy');
this.displayend = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy');
// const s = new Date(this.day).setHours(0, 0, 0, 0).toString();
// const l = new Date(this.day).setHours(23, 59, 59, 999).toString();
this.start = first1;
this.end = last1;
// this.start = this.datePipe.transform(s, 'dd MMM yyyy h:mm a');
// this.end = this.datePipe.transform(l, 'dd MMM yyyy h:mm a');
// alert('s: ' + first1 + '\nL: ' + last1 );
this.data = [];
this.getData();
}
this.i = this.i + 1;
this.day = this.datePipe.transform(this.day, 'dd MMM yyyy h:mm a');
}
async createPdf() {
let a ;
let x ;
let y ;
let z ;
let left;
let right;
let items = [];
let loading = await this.loadingCtrl.create();
await loading.present();
const itemss = [];
for (let i = 0; i < this.data.length; i++) {
itemss.push(
[
{ text: this.data[i].day.toString() , fontSize: 18, color: '#000000' },
{ text: this.data[i].sales.toString() , fontSize: 18, color: '#000000' },
{ text: this.data[i].paid.toString(), fontSize: 18, color: '#000000' }
]
);
}
left = {
text: [
{ text: this.company, bold: true, fontSize: 20, alignment: 'left'},
]
};
right = {
text: [
{ text: this.datePipe.transform(new Date(), 'dd MMM yyyy') , color: '#000000' , fontSize: 18, alignment: 'right'},
]
};
var docDefinition = {
pageSize: 'A4',
pageMargins: [ 20, 20, 20, 20 ],
content: [
{ text: 'SALES BY DAY', bold: true, alignment: 'center', fontSize: 25, style: 'subheader'},
{ text: this.displaystart + ' - ' + this.displayend, bold: true, alignment: 'center', fontSize: 20, style: 'subheader'},
// { margin: [0, 10, 0, 0],
// text: 'CUSTOMER STATEMENT', style: 'header', fontSize: 25, alignment: 'left', color: '#ff0000' },
{
margin: [0, 10, 0, 0],
canvas:
[
{
type: 'line',
x1: 0, y1: 0,
x2: 555, y2: 0,
lineWidth: 3
},
]
},
{
margin: [0, 5, 0, 0],
style: 'totalsTable',
table: {
widths: [ 300, 250 ],
body: [
[
left, right
],
],
},
layout: 'noBorders'
},
{
margin: [0, 20, 0, 0],
text: [
{ text: 'Client ' , style: 'subheader', bold: true, fontSize: 20, color: '#000000' },
{ text: ' Total' , style: 'subheader', bold: true, fontSize: 20, color: '#000000' },
{ text: ' Paid' , style: 'subheader', bold: true, fontSize: 20, color: '#000000' },
]
},
{
margin: [0, 5, 0, 0],
style: 'totalsTable',
table: {
widths: [220, 160, 200 ],
body: itemss
},
layout: 'noBorders'
},
],
styles: {
header: {
fontSize: 18,
bold: true,
},
subheader: {
fontSize: 10,
bold: true,
// margin: [0, 15, 0, 0],
color: '#000000'
},
story: {
italic: true,
alignment: 'center',
width: '50%',
},
backgroundcolor: ''
}
};
this.pdfObj = pdfMake.createPdf(docDefinition);
this.downloadPdf(loading);
// });
}
ionViewWillLeave() {
this.databaseservice.setSalesByDayValue(2);
}
downloadPdf(loading) {
debugger
if (this.plt.is('cordova')) {
this.pdfObj.getBuffer((buffer) => {
// var blob = new Blob([buffer], { type: 'application/pdf' });
var utf8 = new Uint8Array(buffer);
var binaryArray = utf8.buffer;
var blob = new Blob([binaryArray], { type: 'application/pdf' });
const a = new Date().getTime().toString();
this.file.writeFile(this.file.dataDirectory, a + '.pdf', blob).then(fileEntry => {
// this.fileOpener.open(this.file.dataDirectory + a + '.pdf', 'application/pdf');
// loading.dismiss();
});
this.socialSharing.share("test", null, this.file.dataDirectory + a + '.pdf', null).then(() => {
loading.dismiss();
console.log('social share');
console.log(this.file.dataDirectory);
}).catch(() => {
});
debugger
// Save the PDF to the data Directory of our App
// this.file.writeFile(this.file.dataDirectory, 'Invoice4.pdf', blob).then(fileEntry => {
// this.fileOpener.open(this.file.dataDirectory + 'Invoice.pdf', 'application/pdf');
// });
});
} else
|
{
// On a browser simply use download!
this.pdfObj.download();
}
|
conditional_block
|
|
day.page.ts
|
, 'dd MMM yyyy h:mm a');
this.displaystart = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy');
this.displayend = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy');
this.start = first1;
this.end = last1;
// alert('start: ' + this.start + '\n' + this.end);
this.getData();
}
ngOnInit() {
}
share() {
// this.getData();
this.createPdf();
}
back() {
this.router.navigate(['/menu/reports']);
}
onActivate(event) {
if (event.type === 'click') {
console.log(event.row);
}
}
async getData() {
let loading = await this.loadingCtrl.create();
await loading.present();
let now = new Date().toString();
const a = this.datePipe.transform(now, 'dd MMM yyyy h:mm a');
let start = new Date().setHours(0, 0, 0, 0).toString();
const b = this.datePipe.transform(start, 'dd MMM yyyy h:mm a');
// alert('start:' + this.start + '\ncurrent:' + this.end);
// alert('day:' + this.day)
this.syncService.getTodaysSales(this.start, this.end, this.currency).then((data) => {
this.total = data;
console.log(data);
for (let i = 0; i < this.total.length; i++) {
const data1 = {
day: this.total[i].Date,
sales: this.total[i].Total,
paid: this.total[i].Paid
};
this.data.push(data1);
}
this.data = [...this.data];
loading.dismiss();
// alert('y' + this.total[0].Total + 'p' + this.total[0].Paid);
});
}
selectDate() {
var options={
date: new Date(),
mode: 'date',
androidTheme: this.datepicker.ANDROID_THEMES.THEME_DEVICE_DEFAULT_LIGHT
};
this.datepicker.show(options).then((date) => {
this.day = this.datePipe.transform(date, 'dd MMM yyyy h:mm a');
this.data = [];
this.getData();
// console.log('selected:',this.myDate);
});
}
changeDate() {
//alert('yes' + this.data.length);
//alert('y' + this.start);
if ( this.i === 2 || (this.a === 0 && this.i === this.salesvalue)) {
this.i = 0;
this.a = 1;
const firstdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth(), 1).setHours(0, 0, 0, 0);
const first1 = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy h:mm a');
const lastdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth() + 1, 0).setHours(23, 59, 59, 999);
const last1 = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy h:mm a');
this.displaystart = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy');
this.displayend = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy');
// const s = new Date(this.day).setHours(0, 0, 0, 0).toString();
// const l = new Date(this.day).setHours(23, 59, 59, 999).toString();
this.start = first1;
this.end = last1;
// this.start = this.datePipe.transform(s, 'dd MMM yyyy h:mm a');
// this.end = this.datePipe.transform(l, 'dd MMM yyyy h:mm a');
// alert('s: ' + first1 + '\nL: ' + last1 );
this.data = [];
this.getData();
}
this.i = this.i + 1;
this.day = this.datePipe.transform(this.day, 'dd MMM yyyy h:mm a');
}
async createPdf() {
let a ;
let x ;
let y ;
let z ;
let left;
let right;
let items = [];
let loading = await this.loadingCtrl.create();
await loading.present();
const itemss = [];
for (let i = 0; i < this.data.length; i++) {
itemss.push(
[
{ text: this.data[i].day.toString() , fontSize: 18, color: '#000000' },
{ text: this.data[i].sales.toString() , fontSize: 18, color: '#000000' },
{ text: this.data[i].paid.toString(), fontSize: 18, color: '#000000' }
]
);
}
left = {
text: [
{ text: this.company, bold: true, fontSize: 20, alignment: 'left'},
]
};
right = {
text: [
{ text: this.datePipe.transform(new Date(), 'dd MMM yyyy') , color: '#000000' , fontSize: 18, alignment: 'right'},
]
};
var docDefinition = {
pageSize: 'A4',
pageMargins: [ 20, 20, 20, 20 ],
content: [
{ text: 'SALES BY DAY', bold: true, alignment: 'center', fontSize: 25, style: 'subheader'},
{ text: this.displaystart + ' - ' + this.displayend, bold: true, alignment: 'center', fontSize: 20, style: 'subheader'},
// { margin: [0, 10, 0, 0],
// text: 'CUSTOMER STATEMENT', style: 'header', fontSize: 25, alignment: 'left', color: '#ff0000' },
{
margin: [0, 10, 0, 0],
canvas:
[
{
type: 'line',
x1: 0, y1: 0,
x2: 555, y2: 0,
lineWidth: 3
},
]
},
{
margin: [0, 5, 0, 0],
style: 'totalsTable',
table: {
widths: [ 300, 250 ],
body: [
[
left, right
],
],
},
layout: 'noBorders'
},
{
margin: [0, 20, 0, 0],
text: [
{ text: 'Client ' , style: 'subheader', bold: true, fontSize: 20, color: '#000000' },
{ text: ' Total' , style: 'subheader', bold: true, fontSize: 20, color: '#000000' },
{ text: ' Paid' , style: 'subheader', bold: true, fontSize: 20, color: '#000000' },
]
},
{
margin: [0, 5, 0, 0],
style: 'totalsTable',
table: {
widths: [220, 160, 200 ],
body: itemss
},
layout: 'noBorders'
},
],
styles: {
header: {
fontSize: 18,
bold: true,
},
subheader: {
fontSize: 10,
bold: true,
// margin: [0, 15, 0, 0],
color: '#000000'
},
story: {
italic: true,
alignment: 'center',
width: '50%',
},
backgroundcolor: ''
}
};
this.pdfObj = pdfMake.createPdf(docDefinition);
this.downloadPdf(loading);
// });
}
ionViewWillLeave() {
this.databaseservice.setSalesByDayValue(2);
}
downloadPdf(loading) {
debugger
if (this.plt.is('cordova')) {
this.pdfObj.getBuffer((buffer) => {
// var blob = new Blob([buffer], { type: 'application/pdf' });
var utf8 = new Uint8Array(buffer);
var binaryArray = utf8.buffer;
var blob = new Blob([binaryArray], { type: 'application/pdf' });
const a = new Date().getTime().toString();
this.file.writeFile(this.file.dataDirectory, a + '.pdf', blob).then(fileEntry => {
// this.fileOpener.open(this.file.dataDirectory + a + '.pdf', 'application/pdf');
// loading.dismiss();
});
this.socialSharing.share("test", null, this.file.dataDirectory + a + '.pdf', null).then(() => {
loading.dismiss();
console.log('social share');
console.log(this.file.dataDirectory);
}).catch(() => {
|
});
debugger
// Save the PDF to the data Directory of our App
|
random_line_split
|
|
day.page.ts
|
implements OnInit {
style = 'bootstrap';
data = [];
items = [];
total = [];
day = new Date().toString();
start = new Date().setHours(0, 0, 0, 0).toString();
end = new Date().setHours(23, 59, 59, 999).toString();
i = 0;
currency = '';
pdfObj = null;
company = '';
displaystart = '';
displayend = '';
a = 0;
salesvalue = 0;
min = '2020';
max = '';
constructor(
private router: Router,
private syncService: SyncService,
private loadingCtrl: LoadingController,
private datePipe: DatePipe,
private datepicker: DatePicker,
private plt: Platform,
private socialSharing: SocialSharing,
private file: File,
private fileOpener: FileOpener,
private storage: Storage,
private databaseservice: DatabaseService
) {
const last = new Date(new Date().getFullYear(), 11, 31);
this.max = this.datePipe.transform(last, 'yyyy');
this.storage.get('COM').then((val) => {
this.company = val;
});
storage.get('currency').then((val) => {
if (val !== null) {
this.currency = val.toString();
debugger
}
});
this.salesvalue = this.databaseservice.getSalesByDayValue();
this.day = this.datePipe.transform(this.day, 'MMM yyyy h:mm a');
const firstdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth(), 1).setHours(0, 0, 0, 0);
const first1 = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy h:mm a');
const lastdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth() + 1, 0).setHours(23, 59, 59, 999);
const last1 = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy h:mm a');
this.displaystart = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy');
this.displayend = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy');
this.start = first1;
this.end = last1;
// alert('start: ' + this.start + '\n' + this.end);
this.getData();
}
ngOnInit() {
}
share() {
// this.getData();
this.createPdf();
}
back() {
this.router.navigate(['/menu/reports']);
}
onActivate(event) {
if (event.type === 'click') {
console.log(event.row);
}
}
async getData() {
let loading = await this.loadingCtrl.create();
await loading.present();
let now = new Date().toString();
const a = this.datePipe.transform(now, 'dd MMM yyyy h:mm a');
let start = new Date().setHours(0, 0, 0, 0).toString();
const b = this.datePipe.transform(start, 'dd MMM yyyy h:mm a');
// alert('start:' + this.start + '\ncurrent:' + this.end);
// alert('day:' + this.day)
this.syncService.getTodaysSales(this.start, this.end, this.currency).then((data) => {
this.total = data;
console.log(data);
for (let i = 0; i < this.total.length; i++) {
const data1 = {
day: this.total[i].Date,
sales: this.total[i].Total,
paid: this.total[i].Paid
};
this.data.push(data1);
}
this.data = [...this.data];
loading.dismiss();
// alert('y' + this.total[0].Total + 'p' + this.total[0].Paid);
});
}
selectDate() {
var options={
date: new Date(),
mode: 'date',
androidTheme: this.datepicker.ANDROID_THEMES.THEME_DEVICE_DEFAULT_LIGHT
};
this.datepicker.show(options).then((date) => {
this.day = this.datePipe.transform(date, 'dd MMM yyyy h:mm a');
this.data = [];
this.getData();
// console.log('selected:',this.myDate);
});
}
changeDate() {
//alert('yes' + this.data.length);
//alert('y' + this.start);
if ( this.i === 2 || (this.a === 0 && this.i === this.salesvalue)) {
this.i = 0;
this.a = 1;
const firstdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth(), 1).setHours(0, 0, 0, 0);
const first1 = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy h:mm a');
const lastdayofmonth = new Date(new Date(this.day).getFullYear(), new Date(this.day).getMonth() + 1, 0).setHours(23, 59, 59, 999);
const last1 = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy h:mm a');
this.displaystart = this.datePipe.transform(firstdayofmonth, 'dd MMM yyyy');
this.displayend = this.datePipe.transform(lastdayofmonth, 'dd MMM yyyy');
// const s = new Date(this.day).setHours(0, 0, 0, 0).toString();
// const l = new Date(this.day).setHours(23, 59, 59, 999).toString();
this.start = first1;
this.end = last1;
// this.start = this.datePipe.transform(s, 'dd MMM yyyy h:mm a');
// this.end = this.datePipe.transform(l, 'dd MMM yyyy h:mm a');
// alert('s: ' + first1 + '\nL: ' + last1 );
this.data = [];
this.getData();
}
this.i = this.i + 1;
this.day = this.datePipe.transform(this.day, 'dd MMM yyyy h:mm a');
}
async createPdf() {
let a ;
let x ;
let y ;
let z ;
let left;
let right;
let items = [];
let loading = await this.loadingCtrl.create();
await loading.present();
const itemss = [];
for (let i = 0; i < this.data.length; i++) {
itemss.push(
[
{ text: this.data[i].day.toString() , fontSize: 18, color: '#000000' },
{ text: this.data[i].sales.toString() , fontSize: 18, color: '#000000' },
{ text: this.data[i].paid.toString(), fontSize: 18, color: '#000000' }
]
);
}
left = {
text: [
{ text: this.company, bold: true, fontSize: 20, alignment: 'left'},
]
};
right = {
text: [
{ text: this.datePipe.transform(new Date(), 'dd MMM yyyy') , color: '#000000' , fontSize: 18, alignment: 'right'},
]
};
var docDefinition = {
pageSize: 'A4',
pageMargins: [ 20, 20, 20, 20 ],
content: [
{ text: 'SALES BY DAY', bold: true, alignment: 'center', fontSize: 25, style: 'subheader'},
{ text: this.displaystart + ' - ' + this.displayend, bold: true, alignment: 'center', fontSize: 20, style: 'subheader'},
// { margin: [0, 10, 0, 0],
// text: 'CUSTOMER STATEMENT', style: 'header', fontSize: 25, alignment: 'left', color: '#ff0000' },
{
margin: [0, 10, 0, 0],
canvas:
[
{
type: 'line',
x1: 0, y1: 0,
x2: 555, y2: 0,
lineWidth: 3
},
]
},
{
margin: [0, 5, 0, 0],
style: 'totalsTable',
table: {
widths: [ 300, 250 ],
body: [
[
left, right
],
],
},
layout: 'noBorders'
},
{
margin: [0, 20, 0, 0],
text: [
{ text: 'Client ' , style: 'subheader', bold: true, fontSize: 20, color: '#000000' },
{ text: ' Total' , style: 'subheader', bold: true, fontSize: 20, color: '#000000' },
{ text:
|
DayPage
|
identifier_name
|
|
models.py
|
def forward(self, x):
return self.act(self.bn(self.conv(x)))
def fuse_forward(self, x):
# 合并后的前向推理，bn和卷积合并
return self.act(self.conv(x))
class Bottleneck(nn.Module):
'''
标准瓶颈层
'''
def __init__(self, in_channel, out_channel, shortcut=True, groups=1, expansion=0.5): # ch_in, ch_out, shortcut, groups, expansion
super(Bottleneck, self).__init__()
hidden_channel = int(out_channel * expansion) # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = Conv(hidden_channel, out_channel, 3, 1, groups=groups)
self.add = shortcut and in_channel == out_channel
def forward(self, x):
return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
class BottleneckCSP(nn.Module):
# CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks
def __init__(self, in_channel, out_channel, repeats=1, shortcut=True, groups=1, expansion=0.5):
super(BottleneckCSP, self).__init__()
hidden_channel = int(out_channel * expansion) # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = nn.Conv2d(in_channel, hidden_channel, 1, 1, bias=False)
self.cv3 = nn.Conv2d(hidden_channel, hidden_channel, 1, 1, bias=False)
self.cv4 = Conv(2 * hidden_channel, out_channel, 1, 1)
self.bn = nn.BatchNorm2d(2 * hidden_channel) # applied to cat(cv2, cv3)
self.act = nn.LeakyReLU(0.1, inplace=True)
self.m = nn.Sequential(*[Bottleneck(hidden_channel, hidden_channel, shortcut, groups, expansion=1.0) for _ in range(repeats)])
def forward(self, x):
y1 = self.cv3(self.m(self.cv1(x)))
y2 = self.cv2(x)
return self.cv4(self.act(self.bn(torch.cat((y1, y2), dim=1))))
class SPP(nn.Module):
# Spatial pyramid pooling layer used in YOLOv3-SPP
def __init__(self, in_channel, out_channel, kernel_size_list=(5, 9, 13)):
super(SPP, self).__init__()
hidden_channel = in_channel // 2 # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = Conv(hidden_channel * (len(kernel_size_list) + 1), out_channel, 1, 1)
self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=kernel_size, stride=1, padding=kernel_size // 2) for kernel_size in kernel_size_list])
def forward(self, x):
x = self.cv1(x)
return self.cv2(torch.cat([x] + [m(x) for m in self.m], dim=1))
class Focus(nn.Module):
# Focus wh information into c-space
def __init__(self, in_channel, out_channel, kernel_size=1, stride=1, padding=None, groups=1, activation=True):
super(Focus, self).__init__()
self.conv = Conv(in_channel * 4, out_channel, kernel_size, stride, padding, groups, activation)
def forward(self, x): # x(b,c,w,h) -> y(b,4c,w/2,h/2)
return self.conv(torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], dim=1))
class Concat(nn.Module):
# Concatenate a list of tensors along dimension
def __init__(self, dimension=1):
super(Concat, self).__init__()
self.d = dimension
def forward(self, x):
return torch.cat(x, dim=self.d)
class Detect(nn.Module):
def __init__(self, num_classes, num_anchor, reference_channels):
super(Detect, self).__init__()
self.num_anchor = num_anchor
self.num_classes = num_classes
self.num_output = self.num_classes + 5
self.m = nn.ModuleList(nn.Conv2d(input_channel, self.num_output * self.num_anchor, 1) for input_channel in reference_channels)
self.init_weight()
def forward(self, x):
for ilevel, module in enumerate(self.m):
x[ilevel] = module(x[ilevel])
return x
def init_weight(self):
strides = [8, 16, 32]
for head, stride in zip(self.m, strides):
bias = head.bias.view(self.num_anchor, -1)
bias[:, 4] += math.log(8 / (640 / stride) ** 2)
bias[:, 5:] += math.log(0.6 / (self.num_classes - 0.99))
head.bias = nn.Parameter(bias.view(-1), requires_grad=True)
class Yolo(nn.Module):
def __init__(self, num_classes, config_file, rank=0):
super(Yolo, self).__init__()
self.num_classes = num_classes
self.rank = rank
self.strides = [8, 16, 32]
self.model, self.saved_index, anchors = self.build_model(config_file)
self.register_buffer("anchors", torch.FloatTensor(anchors).view(3, 3, 2) / torch.FloatTensor(self.strides).view(3, 1, 1))
self.apply(self.init_weight)
def set_new_anchors(self, anchors):
# 对设置的anchors缩放到特征图大小
self.anchors[...] = anchors / torch.FloatTensor(self.strides).view(3, 1, 1)
def init_weight(self, m):
type_t = type(m)
if type_t is nn.Conv2d:
# pass init
pass
elif type_t is nn.BatchNorm2d:
m.eps = 1e-3
m.momentum = 0.03
elif type_t in [nn.LeakyReLU, nn.ReLU, nn.ReLU6]:
m.inplace = True
def forward(self, x):
y = []
for module in self.model:
if module.from_index != -1:
if isinstance(module.from_index, int):
x = y[module.from_index]
else:
xout = []
for i in module.from_index:
if i == -1:
xval = x
else:
xval = y[i]
xout.append(xval)
x = xout
x = module(x)
y.append(x if module.layer_index in self.saved_index else None)
return x
def parse_string(self, value):
if value == "None":
return None
elif value == "True":
return True
elif value == "False":
return False
else:
return value
def fuse(self): # fuse model Conv2d() + BatchNorm2d() layers
print('Fusing layers... ', end='')
for m in self.model.modules():
if type(m) is Conv:
m.conv = nn_utils.fuse_conv_and_bn(m.conv, m.bn) # update conv
m.bn = None # remove batchnorm
m.forward = m.fuse_forward # update forward
return self
def build_model(self, config_file, input_channel=3):
with open(config_file) as f:
self.yaml = yaml.load(f, Loader=yaml.FullLoader)
all_layers_cfg_list = self.yaml["backbone"] + self.yaml["head"]
anchors, depth_multiple, width_multiple = [self.yaml[item] for item in ["anchors", "depth_multiple", "width_multiple"]]
num_classes = self.num_classes
num_anchor = len(anchors[0]) // 2
num_output = num_anchor * (num_classes + 5)
|
args = [self.parse_string(a) for a in args]
module_function = eval(module_name)
if repeat_count > 1:
repeat_count = max(round(repeat_count * depth_multiple), 1)
if module_function in [Conv, Bottleneck, SPP, Focus, BottleneckCSP]:
channel_input, channel_output = all_layers_channels[from_index], args[0]
if channel_output != num_output:
channel_output = make_divisible(channel_output * width_multiple, 8)
args = [channel_input, channel_output, *args[1:]]
if module_function in [BottleneckCSP]:
args.insert(2, repeat_count)
repeat_count = 1
elif module_function is Concat:
channel_output = sum([all_layers_channels[-1 if x == -1 else x + 1] for x in from_index])
elif
|
all_layers_channels = [input_channel]
all_layers = []
saved_layer_index = []
for layer_index, (from_index, repeat_count, module_name, args) in enumerate(all_layers_cfg_list):
|
random_line_split
|
models.py
|
def autopad(kernel, padding=None): # kernel, padding
# Pad to 'same'
if padding is None:
padding = kernel // 2 if isinstance(kernel, int) else [x // 2 for x in kernel] # auto-pad
return padding
class Conv(nn.Module):
'''
标准卷积层
'''
def __init__(self, in_channel, out_channel, kernel_size=1, stride=1, padding=None, groups=1, activation=True):
super(Conv, self).__init__()
self.conv = nn.Conv2d(in_channel, out_channel, kernel_size, stride, autopad(kernel_size, padding), groups=groups, bias=False)
self.bn = nn.BatchNorm2d(out_channel)
self.act = nn.LeakyReLU(0.1, inplace=True) if activation else nn.Identity()
def forward(self, x):
return self.act(self.bn(self.conv(x)))
def fuse_forward(self, x):
# 合并后的前向推理，bn和卷积合并
return self.act(self.conv(x))
class Bottleneck(nn.Module):
'''
标准瓶颈层
'''
def __init__(self, in_channel, out_channel, shortcut=True, groups=1, expansion=0.5): # ch_in, ch_out, shortcut, groups, expansion
super(Bottleneck, self).__init__()
hidden_channel = int(out_channel * expansion) # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = Conv(hidden_channel, out_channel, 3, 1, groups=groups)
self.add = shortcut and in_channel == out_channel
def forward(self, x):
return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
class BottleneckCSP(nn.Module):
# CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks
def __init__(self, in_channel, out_channel, repeats=1, shortcut=True, groups=1, expansion=0.5):
super(BottleneckCSP, self).__init__()
hidden_channel = int(out_channel * expansion) # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = nn.Conv2d(in_channel, hidden_channel, 1, 1, bias=False)
self.cv3 = nn.Conv2d(hidden_channel, hidden_channel, 1, 1, bias=False)
self.cv4 = Conv(2 * hidden_channel, out_channel, 1, 1)
self.bn = nn.BatchNorm2d(2 * hidden_channel) # applied to cat(cv2, cv3)
self.act = nn.LeakyReLU(0.1, inplace=True)
self.m = nn.Sequential(*[Bottleneck(hidden_channel, hidden_channel, shortcut, groups, expansion=1.0) for _ in range(repeats)])
def forward(self, x):
y1 = self.cv3(self.m(self.cv1(x)))
y2 = self.cv2(x)
return self.cv4(self.act(self.bn(torch.cat((y1, y2), dim=1))))
class SPP(nn.Module):
# Spatial pyramid pooling layer used in YOLOv3-SPP
def __init__(self, in_channel, out_channel, kernel_size_list=(5, 9, 13)):
super(SPP, self).__init__()
hidden_channel = in_channel // 2 # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = Conv(hidden_channel * (len(kernel_size_list) + 1), out_channel, 1, 1)
self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=kernel_size, stride=1, padding=kernel_size // 2) for kernel_size in kernel_size_list])
def forward(self, x):
x = self.cv1(x)
return self.cv2(torch.cat([x] + [m(x) for m in self.m], dim=1))
class Focus(nn.Module):
# Focus wh information into c-space
def __init__(self, in_channel, out_channel, kernel_size=1, stride=1, padding=None, groups=1, activation=True):
super(Focus, self).__init__()
self.conv = Conv(in_channel * 4, out_channel, kernel_size, stride, padding, groups, activation)
def forward(self, x): # x(b,c,w,h) -> y(b,4c,w/2,h/2)
return self.conv(torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], dim=1))
class Concat(nn.Module):
# Concatenate a list of tensors along dimension
def __init__(self, dimension=1):
super(Concat, self).__init__()
self.d = dimension
def forward(self, x):
return torch.cat(x, dim=self.d)
class Detect(nn.Module):
def __init__(self, num_classes, num_anchor, reference_channels):
super(Detect, self).__init__()
self.num_anchor = num_anchor
self.num_classes = num_classes
self.num_output = self.num_classes + 5
self.m = nn.ModuleList(nn.Conv2d(input_channel, self.num_output * self.num_anchor, 1) for input_channel in reference_channels)
self.init_weight()
def forward(self, x):
for ilevel, module in enumerate(self.m):
x[ilevel] = module(x[ilevel])
return x
def init_weight(self):
strides = [8, 16, 32]
for head, stride in zip(self.m, strides):
bias = head.bias.view(self.num_anchor, -1)
bias[:, 4] += math.log(8 / (640 / stride) ** 2)
bias[:, 5:] += math.log(0.6 / (self.num_classes - 0.99))
head.bias = nn.Parameter(bias.view(-1), requires_grad=True)
class Yolo(nn.Module):
def __init__(self, num_classes, config_file, rank=0):
super(Yolo, self).__init__()
self.num_classes = num_classes
self.rank = rank
self.strides = [8, 16, 32]
self.model, self.saved_index, anchors = self.build_model(config_file)
self.register_buffer("anchors", torch.FloatTensor(anchors).view(3, 3, 2) / torch.FloatTensor(self.strides).view(3, 1, 1))
self.apply(self.init_weight)
def set_new_anchors(self, anchors):
# 对设置的anchors缩放到特征图大小
self.anchors[...] = anchors / torch.FloatTensor(self.strides).view(3, 1, 1)
def init_weight(self, m):
type_t = type(m)
if type_t is nn.Conv2d:
# pass init
pass
elif type_t is nn.BatchNorm2d:
m.eps = 1e-3
m.momentum = 0.03
elif type_t in [nn.LeakyReLU, nn.ReLU, nn.ReLU6]:
m.inplace = True
def forward(self, x):
y = []
for module in self.model:
if module.from_index != -1:
if isinstance(module.from_index, int):
x = y[module.from_index]
else:
xout = []
for i in module.from_index:
if i == -1:
xval = x
else:
xval = y[i]
xout.append(xval)
x = xout
x = module(x)
y.append(x if module.layer_index in self.saved_index else None)
return x
def parse_string(self, value):
if value == "None":
return None
elif value == "True":
return True
elif value == "False":
return False
else:
return value
def fuse(self): # fuse model Conv2d() + BatchNorm2d() layers
print('Fusing layers... ', end='')
for m in self.model.modules():
if type(m) is Conv:
m.conv = nn_utils.fuse_conv_and_bn(m.conv, m.bn) # update conv
m.bn = None # remove batchnorm
m.forward = m.fuse_forward # update forward
return self
def build_model(self, config_file, input_channel=3):
with open(config_file) as f:
self.yaml = yaml.load(f, Loader=yaml.FullLoader)
all_layers_cfg_list = self.yaml["backbone"] + self.yaml["head"]
anchors, depth_multiple, width_multiple = [self.yaml[item] for item in ["anchors", "depth_multiple", "width_multiple"]]
num_classes = self.num_classes
num_anchor = len(anchors[0]) // 2
num_output = num_anchor * (num_classes + 5)
all_layers_channels = [input_channel]
all_layers = []
saved_layer_index = []
for layer_index, (from_index, repeat_count, module_name, args) in enumerate(all
|
return math.ceil(x / divisor) * divisor
|
identifier_body
|
|
models.py
|
forward(self, x):
return self.act(self.bn(self.conv(x)))
def fuse_forward(self, x):
# 合并后的前向推理，bn和卷积合并
return self.act(self.conv(x))
class Bottleneck(nn.Module):
'''
标准瓶颈层
'''
def __init__(self, in_channel, out_channel, shortcut=True, groups=1, expansion=0.5): # ch_in, ch_out, shortcut, groups, expansion
super(Bottleneck, self).__init__()
hidden_channel = int(out_channel * expansion) # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = Conv(hidden_channel, out_channel, 3, 1, groups=groups)
self.add = shortcut and in_channel == out_channel
def forward(self, x):
return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
class BottleneckCSP(nn.Module):
# CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks
def __init__(self, in_channel, out_channel, repeats=1, shortcut=True, groups=1, expansion=0.5):
super(BottleneckCSP, self).__init__()
hidden_channel = int(out_channel * expansion) # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = nn.Conv2d(in_channel, hidden_channel, 1, 1, bias=False)
self.cv3 = nn.Conv2d(hidden_channel, hidden_channel, 1, 1, bias=False)
self.cv4 = Conv(2 * hidden_channel, out_channel, 1, 1)
self.bn = nn.BatchNorm2d(2 * hidden_channel) # applied to cat(cv2, cv3)
self.act = nn.LeakyReLU(0.1, inplace=True)
self.m = nn.Sequential(*[Bottleneck(hidden_channel, hidden_channel, shortcut, groups, expansion=1.0) for _ in range(repeats)])
def forward(self, x):
y1 = self.cv3(self.m(self.cv1(x)))
y2 = self.cv2(x)
return self.cv4(self.act(self.bn(torch.cat((y1, y2), dim=1))))
class SPP(nn.Module):
# Spatial pyramid pooling layer used in YOLOv3-SPP
def __init__(self, in_channel, out_channel, kernel_size_list=(5, 9, 13)):
super(SPP, self).__init__()
hidden_channel = in_channel // 2 # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = Conv(hidden_channel * (len(kernel_size_list) + 1), out_channel, 1, 1)
self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=kernel_size, stride=1, padding=kernel_size // 2) for kernel_size in kernel_size_list])
def forward(self, x):
x = self.cv1(x)
return self.cv2(torch.cat([x] + [m(x) for m in self.m], dim=1))
class Focus(nn.Module):
# Focus wh information into c-space
def __init__(self, in_channel, out_channel, kernel_size=1, stride=1, padding=None, groups=1, activation=True):
super(Focus, self).__init__()
self.conv = Conv(in_channel * 4, out_channel, kernel_size, stride, padding, groups, activation)
def forward(self, x): # x(b,c,w,h) -> y(b,4c,w/2,h/2)
return self.conv(torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], dim=1))
class Concat(nn.Module):
# Concatenate a list of tensors along dimension
def __init__(self, dimension=1):
super(Concat, self).__init__()
self.d = dimension
def forward(self, x):
return torch.cat(x, dim=self.d)
class Detect(nn.Module):
def __init__(self, num_classes, num_anchor, reference_channels):
super(Detect, self).__init__()
self.num_anchor = num_anchor
self.num_classes = num_classes
self.num_output = self.num_classes + 5
self.m = nn.ModuleList(nn.Conv2d(input_channel, self.num_output * self.num_anchor, 1) for input_channel in reference_channels)
self.init_weight()
def forward(self, x):
for ilevel, module in enumerate(self.m):
x[ilevel] = module(x[ilevel])
return x
|
strides = [8, 16, 32]
for head, stride in zip(self.m, strides):
bias = head.bias.view(self.num_anchor, -1)
bias[:, 4] += math.log(8 / (640 / stride) ** 2)
bias[:, 5:] += math.log(0.6 / (self.num_classes - 0.99))
head.bias = nn.Parameter(bias.view(-1), requires_grad=True)
class Yolo(nn.Module):
def __init__(self, num_classes, config_file, rank=0):
super(Yolo, self).__init__()
self.num_classes = num_classes
self.rank = rank
self.strides = [8, 16, 32]
self.model, self.saved_index, anchors = self.build_model(config_file)
self.register_buffer("anchors", torch.FloatTensor(anchors).view(3, 3, 2) / torch.FloatTensor(self.strides).view(3, 1, 1))
self.apply(self.init_weight)
def set_new_anchors(self, anchors):
# 对设置的anchors缩放到特征图大小
self.anchors[...] = anchors / torch.FloatTensor(self.strides).view(3, 1, 1)
def init_weight(self, m):
type_t = type(m)
if type_t is nn.Conv2d:
# pass init
pass
elif type_t is nn.BatchNorm2d:
m.eps = 1e-3
m.momentum = 0.03
elif type_t in [nn.LeakyReLU, nn.ReLU, nn.ReLU6]:
m.inplace = True
def forward(self, x):
y = []
for module in self.model:
if module.from_index != -1:
if isinstance(module.from_index, int):
x = y[module.from_index]
else:
xout = []
for i in module.from_index:
if i == -1:
xval = x
else:
xval = y[i]
xout.append(xval)
x = xout
x = module(x)
y.append(x if module.layer_index in self.saved_index else None)
return x
def parse_string(self, value):
if value == "None":
return None
elif value == "True":
return True
elif value == "False":
return False
else:
return value
def fuse(self): # fuse model Conv2d() + BatchNorm2d() layers
print('Fusing layers... ', end='')
for m in self.model.modules():
if type(m) is Conv:
m.conv = nn_utils.fuse_conv_and_bn(m.conv, m.bn) # update conv
m.bn = None # remove batchnorm
m.forward = m.fuse_forward # update forward
return self
def build_model(self, config_file, input_channel=3):
with open(config_file) as f:
self.yaml = yaml.load(f, Loader=yaml.FullLoader)
all_layers_cfg_list = self.yaml["backbone"] + self.yaml["head"]
anchors, depth_multiple, width_multiple = [self.yaml[item] for item in ["anchors", "depth_multiple", "width_multiple"]]
num_classes = self.num_classes
num_anchor = len(anchors[0]) // 2
num_output = num_anchor * (num_classes + 5)
all_layers_channels = [input_channel]
all_layers = []
saved_layer_index = []
for layer_index, (from_index, repeat_count, module_name, args) in enumerate(all_layers_cfg_list):
args = [self.parse_string(a) for a in args]
module_function = eval(module_name)
if repeat_count > 1:
repeat_count = max(round(repeat_count * depth_multiple), 1)
if module_function in [Conv, Bottleneck, SPP, Focus, BottleneckCSP]:
channel_input, channel_output = all_layers_channels[from_index], args[0]
if channel_output != num_output:
channel_output = make_divisible(channel_output * width_multiple, 8)
args = [channel_input, channel_output, *args[1:]]
if module_function in [BottleneckCSP]:
args.insert(2, repeat_count)
repeat_count = 1
elif module_function is Concat:
channel_output = sum([all_layers_channels[-1 if x == -1 else x + 1] for x in from_index])
elif
|
def init_weight(self):
|
conditional_block
|
models.py
|
forward(self, x):
return self.act(self.bn(self.conv(x)))
def fuse_forward(self, x):
# 合并后的前向推理，bn和卷积合并
return self.act(self.conv(x))
class Bottleneck(nn.Module):
'''
标准瓶颈层
'''
def __init__(self, in_channel, out_channel, shortcut=True, groups=1, expansion=0.5): # ch_in, ch_out, shortcut, groups, expansion
super(Bottleneck, self).__init__()
hidden_channel = int(out_channel * expansion) # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = Conv(hidden_channel, out_channel, 3, 1, groups=groups)
self.add = shortcut and in_channel == out_channel
def forward(self, x):
return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
class BottleneckCSP(nn.Module):
# CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks
def __init__(self, in_channel, out_channel, repeats=1, shortcut=True, groups=1, expansion=0.5):
super(BottleneckCSP, self).__init__()
hidden_channel = int(out_channel * expansion) # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = nn.Conv2d(in_channel, hidden_channel, 1, 1, bias=False)
self.cv3 = nn.Conv2d(hidden_channel, hidden_channel, 1, 1, bias=False)
self.cv4 = Conv(2 * hidden_channel, out_channel, 1, 1)
self.bn = nn.BatchNorm2d(2 * hidden_channel) # applied to cat(cv2, cv3)
self.act = nn.LeakyReLU(0.1, inplace=True)
self.m = nn.Sequential(*[Bottleneck(hidden_channel, hidden_channel, shortcut, groups, expansion=1.0) for _ in range(repeats)])
def forward(self, x):
y1 = self.cv3(self.m(self.cv1(x)))
y2 = self.cv2(x)
return self.cv4(self.act(self.bn(torch.cat((y1, y2), dim=1))))
class SPP(nn.Module):
# Spatial pyramid pooling layer used in YOLOv3-SPP
def __init__(self, in_channel, out_channel, kernel_size_list=(5, 9, 13)):
super(SPP, self).__init__()
hidden_channel = in_channel // 2 # hidden channels
self.cv1 = Conv(in_channel, hidden_channel, 1, 1)
self.cv2 = Conv(hidden_channel * (len(kernel_size_list) + 1), out_channel, 1, 1)
self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=kernel_size, stride=1, padding=kernel_size // 2) for kernel_size in kernel_size_list])
def forward(self, x):
x = self.cv1(x)
return self.cv2(torch.cat([x] + [m(x) for m in self.m], dim=1))
class Focus(nn.Module):
# Focus wh information into c-space
def __init__(self, in_channel, out_channel, kernel_size=1, stride=1, padding=None, groups=1, activation=True):
super(Focus, self).__init__()
self.conv = Conv(in_channel * 4, out_channel, kernel_size, stride, padding, groups, activation)
def forward(self, x): # x(b,c,w,h) -> y(b,4c,w/2,h/2)
return self.conv(torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], dim=1))
class Concat(nn.Module):
# Concatenate a list of tensors along dimension
def __init__(self, dimension=1):
super(Concat, self).__init__()
self.d = dimension
def forward(self, x):
return torch.cat(x, di
|
d)
class Detect(nn.Module):
def __init__(self, num_classes, num_anchor, reference_channels):
super(Detect, self).__init__()
self.num_anchor = num_anchor
self.num_classes = num_classes
self.num_output = self.num_classes + 5
self.m = nn.ModuleList(nn.Conv2d(input_channel, self.num_output * self.num_anchor, 1) for input_channel in reference_channels)
self.init_weight()
def forward(self, x):
for ilevel, module in enumerate(self.m):
x[ilevel] = module(x[ilevel])
return x
def init_weight(self):
strides = [8, 16, 32]
for head, stride in zip(self.m, strides):
bias = head.bias.view(self.num_anchor, -1)
bias[:, 4] += math.log(8 / (640 / stride) ** 2)
bias[:, 5:] += math.log(0.6 / (self.num_classes - 0.99))
head.bias = nn.Parameter(bias.view(-1), requires_grad=True)
class Yolo(nn.Module):
def __init__(self, num_classes, config_file, rank=0):
super(Yolo, self).__init__()
self.num_classes = num_classes
self.rank = rank
self.strides = [8, 16, 32]
self.model, self.saved_index, anchors = self.build_model(config_file)
self.register_buffer("anchors", torch.FloatTensor(anchors).view(3, 3, 2) / torch.FloatTensor(self.strides).view(3, 1, 1))
self.apply(self.init_weight)
def set_new_anchors(self, anchors):
# 对设置的anchors缩放到特征图大小
self.anchors[...] = anchors / torch.FloatTensor(self.strides).view(3, 1, 1)
def init_weight(self, m):
type_t = type(m)
if type_t is nn.Conv2d:
# pass init
pass
elif type_t is nn.BatchNorm2d:
m.eps = 1e-3
m.momentum = 0.03
elif type_t in [nn.LeakyReLU, nn.ReLU, nn.ReLU6]:
m.inplace = True
def forward(self, x):
y = []
for module in self.model:
if module.from_index != -1:
if isinstance(module.from_index, int):
x = y[module.from_index]
else:
xout = []
for i in module.from_index:
if i == -1:
xval = x
else:
xval = y[i]
xout.append(xval)
x = xout
x = module(x)
y.append(x if module.layer_index in self.saved_index else None)
return x
def parse_string(self, value):
if value == "None":
return None
elif value == "True":
return True
elif value == "False":
return False
else:
return value
def fuse(self): # fuse model Conv2d() + BatchNorm2d() layers
print('Fusing layers... ', end='')
for m in self.model.modules():
if type(m) is Conv:
m.conv = nn_utils.fuse_conv_and_bn(m.conv, m.bn) # update conv
m.bn = None # remove batchnorm
m.forward = m.fuse_forward # update forward
return self
def build_model(self, config_file, input_channel=3):
with open(config_file) as f:
self.yaml = yaml.load(f, Loader=yaml.FullLoader)
all_layers_cfg_list = self.yaml["backbone"] + self.yaml["head"]
anchors, depth_multiple, width_multiple = [self.yaml[item] for item in ["anchors", "depth_multiple", "width_multiple"]]
num_classes = self.num_classes
num_anchor = len(anchors[0]) // 2
num_output = num_anchor * (num_classes + 5)
all_layers_channels = [input_channel]
all_layers = []
saved_layer_index = []
for layer_index, (from_index, repeat_count, module_name, args) in enumerate(all_layers_cfg_list):
args = [self.parse_string(a) for a in args]
module_function = eval(module_name)
if repeat_count > 1:
repeat_count = max(round(repeat_count * depth_multiple), 1)
if module_function in [Conv, Bottleneck, SPP, Focus, BottleneckCSP]:
channel_input, channel_output = all_layers_channels[from_index], args[0]
if channel_output != num_output:
channel_output = make_divisible(channel_output * width_multiple, 8)
args = [channel_input, channel_output, *args[1:]]
if module_function in [BottleneckCSP]:
args.insert(2, repeat_count)
repeat_count = 1
elif module_function is Concat:
channel_output = sum([all_layers_channels[-1 if x == -1 else x + 1] for x in from_index])
|
m=self.
|
identifier_name
|
filetrace_test.go
|
0 exit_group(0) = ?`,
}
// TestStraceParse1 tests strace level1 parser (joining) by counting and
// checking strings.
func TestStraceParse1(t *testing.T) {
// Count strings that will be parsed away by StraceParser1
n := len(straceout)
for _, l := range straceout {
if strings.Contains(l, "resumed") || strings.Contains(l, "--- SIG") {
n--
continue
}
m, err := regexp.MatchString("^[0-9]+ \\?.*", l)
if err != nil {
t.Error(err)
}
if m {
n--
continue
}
}
if n == len(straceout) {
t.Error("test string has no level 1 parser tokens")
}
// Parse, and check that they went away and that the count is right
parsed := make([]string, 0, len(straceout))
for l := range StraceParse1(ChanFromList(straceout)) {
if strings.Contains(l, "resumed") || strings.Contains(l, "finished") {
t.Error("found invalid string in parsed results: " + l)
}
parsed = append(parsed, l)
}
if len(parsed) != n {
t.Error("incorrect len of parsed strings")
}
}
// TestStraceParse2Basic tests strace level2 parser by counting parsed entities.
func TestStraceParse2Basic(t *testing.T) {
nopen := 0
nexec := 0
for _, l := range straceout {
if strings.Contains(l, " open(") {
nopen++
}
if strings.Contains(l, " execve(") {
nexec++
}
}
syscalls := map[string]int{}
for info := range StraceParse2(StraceParse1(ChanFromList(straceout))) {
syscalls[info.syscall]++
}
if nopen != syscalls["open"] {
t.Errorf("\"open\" count mismatch: %d != %d", nopen, syscalls["open"])
}
if nexec != syscalls["execve"] {
t.Errorf("\"execve\" count mismatch: %d != %d", nexec, syscalls["execve"])
}
}
// TestStraceParse2Args tests strace level2 argument splitting.
func TestStraceParse2Args(t *testing.T) {
tests := []struct {
str string
ans []string
}{
{"asdf", []string{"asdf"}},
{"as, df", []string{"as", "df"}},
{"a {s, d} f", []string{"a {s, d} f"}},
{"{as, df}", []string{"{as, df}"}},
{`"as, df"`, []string{`"as, df"`}},
{`"as, df", gh`, []string{`"as, df"`, "gh"}},
{`"as, df\", gh"`, []string{`"as, df\", gh"`}},
{`"as, df\""`, []string{`"as, df\""`}},
}
for _, tst := range tests {
a := StraceParse2Argsplit(tst.str)
if !reflect.DeepEqual(a, tst.ans) {
t.Error(a, "!=", tst.ans)
}
}
}
// TestStraceParse2Lines tests a specific line-parsing.
func TestStraceParse2Lines(t *testing.T) {
c := make(chan string)
go func() {
defer close(c)
c <- `16821 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3`
}()
for info := range StraceParse2(c) {
tests := []struct {
ok bool
str string
}{
{info.pid == 16821, "pid mismatch"},
{info.syscall == "open", "syscall mismatch"},
{info.result == 3, "result mismatch"},
{info.body == `"/etc/ld.so.cache", O_RDONLY|O_CLOEXEC`, "body mismatch"},
{info.err == "", "error mismatch"},
}
for _, tst := range tests {
if !tst.ok {
t.Error(tst.str)
}
}
ans := []string{
`"/etc/ld.so.cache"`,
`O_RDONLY|O_CLOEXEC`,
}
if len(ans) != len(info.args) {
t.Errorf("args len mismatch: len(%s)=%d != len(%s)=%d", info.args, len(info.args), ans, len(ans))
}
for i := 0; i < len(info.args); i++ {
if ans[i] != info.args[i] {
t.Errorf("arg %d mismatch", i)
}
}
}
}
// TestStraceParse3 tests StraceParse3 and StraceParse2
func TestStraceParse3(t *testing.T) {
c := make(chan string)
go func() {
defer close(c)
c <- `16821 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3`
c <- `16821 open("w", O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC) = 4`
c <- `16821 open("r", O_RDONLY|O_CLOEXEC) = 5`
c <- `16821 open("rw", O_RDWR|O_NONBLOCK) = 6`
c <- `16821 creat("c", 01) = 6`
}()
r, w := StraceParse3(StraceParse2(c), "")
rok := map[string]bool{
"/etc/ld.so.cache": true,
"r": true,
"rw": true,
}
if !reflect.DeepEqual(r, rok) {
t.Error(r, "!=", rok)
}
wok := map[string]bool{
"w": true,
"c": true,
"rw": true,
}
if !reflect.DeepEqual(w, wok) {
t.Error(w, "!=", wok)
}
}
// Test real applications:
// straceRbase has the base read files for the OS where the tests are run.
var straceRbase map[string]bool
// empty is an empty map
var empty = map[string]bool{}
// filetraceTest is the primitive test function that runs the provided command
// and checks if the set of files read and written match the ones provided.
func filetraceTest(t *testing.T, cmd string, dir string, rok map[string]bool, wok map[string]bool) {
if len(straceRbase) == 0 {
straceRbase, _ = FileTrace("", nil, "")
}
rt, wt := FileTrace(cmd, nil, dir)
rok2 := map[string]bool{}
for r := range rok {
rok2[r] = true
}
for r := range straceRbase {
rok2[r] = true
}
if !reflect.DeepEqual(rt, rok2) {
t.Error("r", rt, "!=", rok2)
}
if !reflect.DeepEqual(wt, wok) {
t.Error("w", wt, "!=", wok)
}
}
// TestFiletraceEchocat is the base test of read/write that runs an echo with the
// output redirected to a file, and a cat that reads that file.
func TestFiletraceEchocat(t *testing.T) {
empty := map[string]bool{}
filetraceTest(t,
"echo asdf > t",
"",
empty,
map[string]bool{"t": true})
defer func() {
if err := os.Remove("t"); err != nil {
t.Error(err)
}
}()
filetraceTest(t,
"cat t > h",
"",
map[string]bool{"t": true},
map[string]bool{"h": true})
defer func() {
if err := os.Remove("h"); err != nil {
t.Error(err)
}
}()
filetraceTest(t,
"cp t j",
"",
map[string]bool{"t": true},
map[string]bool{"j": true})
defer func() {
if err := os.Remove("j"); err != nil {
t.Error(err)
}
}()
}
// TestFiletraceChdir tests directory chaging.
func TestFiletraceChdir(t *testing.T) {
filetraceTest(t,
"mkdir d; cd d; echo asdf > t",
"",
empty,
map[string]bool{"d/t": true})
defer func() {
if err := os.Remove("d/t"); err != nil {
t.Error(err)
}
if err := os.Remove("d"); err != nil {
t.Error(err)
}
}()
}
// TestFiletraceEnv tests the environment argument.
func TestFiletraceEnv(t *testing.T) {
FileTrace("env > e.txt", map[string]string{"x": "y"}, "")
defer func() {
if err := os.Remove("e.txt"); err != nil
|
{
t.Error(err)
}
|
conditional_block
|
|
filetrace_test.go
|
explain"], [/* 34 vars */]) = -1 ENOENT (No such file or directory)`,
`16820 --- SIGCHLD (Child exited) @ 0 (0) ---`,
`16820 execve("/usr/bin/tclsh", ["tclsh", "/usr/bin/unbuffer", "scons", "--max-drift=1", "--implicit-cache", "--debug=explain"], [/* 34 vars */]) = 0`,
`16820 execve("/usr/bin/tclsh", ["tclsh", "/usr/bin/unbuffer", "scons", "--max-drift=1", "--implicit-cache", "--debug=explain"], [/* 34 vars */]) = ? <unavailable>`,
`16820 ????(= ? <unavailable>`,
`16821 open("/dev/tty", O_RDWR|O_NONBLOCK|O_LARGEFILE) = 3`,
`16820 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC <unfinished ...>`,
`16820 <... ???? resumed> ) = ? <unavailable>`,
`16821 open("/usr/lib/locale/locale-archive", O_RDONLY|O_LARGEFILE|O_CLOEXEC <unfinished ...>`,
`16820 <... open resumed> ) = 3`,
`16821 <... open resumed> ) = 3`,
`16820 open("/usr/lib\"/libtcl8.5.so.0", O_RDONLY|O_CLOEXEC) = 3`,
`16820 exit_group(0) = ?`,
}
// TestStraceParse1 tests strace level1 parser (joining) by counting and
// checking strings.
func TestStraceParse1(t *testing.T) {
// Count strings that will be parsed away by StraceParser1
n := len(straceout)
for _, l := range straceout {
if strings.Contains(l, "resumed") || strings.Contains(l, "--- SIG") {
n--
continue
}
m, err := regexp.MatchString("^[0-9]+ \\?.*", l)
if err != nil {
t.Error(err)
}
if m {
n--
continue
}
}
if n == len(straceout) {
t.Error("test string has no level 1 parser tokens")
}
// Parse, and check that they went away and that the count is right
parsed := make([]string, 0, len(straceout))
for l := range StraceParse1(ChanFromList(straceout)) {
if strings.Contains(l, "resumed") || strings.Contains(l, "finished") {
t.Error("found invalid string in parsed results: " + l)
}
parsed = append(parsed, l)
}
if len(parsed) != n {
t.Error("incorrect len of parsed strings")
}
}
// TestStraceParse2Basic tests strace level2 parser by counting parsed entities.
func TestStraceParse2Basic(t *testing.T) {
nopen := 0
nexec := 0
for _, l := range straceout {
if strings.Contains(l, " open(") {
nopen++
}
if strings.Contains(l, " execve(") {
nexec++
}
}
syscalls := map[string]int{}
for info := range StraceParse2(StraceParse1(ChanFromList(straceout))) {
syscalls[info.syscall]++
}
if nopen != syscalls["open"] {
t.Errorf("\"open\" count mismatch: %d != %d", nopen, syscalls["open"])
}
if nexec != syscalls["execve"] {
t.Errorf("\"execve\" count mismatch: %d != %d", nexec, syscalls["execve"])
}
}
// TestStraceParse2Args tests strace level2 argument splitting.
func TestStraceParse2Args(t *testing.T) {
tests := []struct {
str string
ans []string
}{
{"asdf", []string{"asdf"}},
{"as, df", []string{"as", "df"}},
{"a {s, d} f", []string{"a {s, d} f"}},
{"{as, df}", []string{"{as, df}"}},
{`"as, df"`, []string{`"as, df"`}},
{`"as, df", gh`, []string{`"as, df"`, "gh"}},
{`"as, df\", gh"`, []string{`"as, df\", gh"`}},
{`"as, df\""`, []string{`"as, df\""`}},
}
for _, tst := range tests {
a := StraceParse2Argsplit(tst.str)
if !reflect.DeepEqual(a, tst.ans) {
t.Error(a, "!=", tst.ans)
}
}
}
// TestStraceParse2Lines tests a specific line-parsing.
func TestStraceParse2Lines(t *testing.T) {
c := make(chan string)
go func() {
defer close(c)
c <- `16821 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3`
}()
for info := range StraceParse2(c) {
tests := []struct {
ok bool
str string
}{
{info.pid == 16821, "pid mismatch"},
{info.syscall == "open", "syscall mismatch"},
{info.result == 3, "result mismatch"},
{info.body == `"/etc/ld.so.cache", O_RDONLY|O_CLOEXEC`, "body mismatch"},
{info.err == "", "error mismatch"},
}
for _, tst := range tests {
if !tst.ok {
t.Error(tst.str)
}
}
ans := []string{
`"/etc/ld.so.cache"`,
`O_RDONLY|O_CLOEXEC`,
}
if len(ans) != len(info.args) {
t.Errorf("args len mismatch: len(%s)=%d != len(%s)=%d", info.args, len(info.args), ans, len(ans))
}
for i := 0; i < len(info.args); i++ {
if ans[i] != info.args[i] {
t.Errorf("arg %d mismatch", i)
}
}
}
}
// TestStraceParse3 tests StraceParse3 and StraceParse2
func TestStraceParse3(t *testing.T) {
c := make(chan string)
go func() {
defer close(c)
c <- `16821 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3`
c <- `16821 open("w", O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC) = 4`
c <- `16821 open("r", O_RDONLY|O_CLOEXEC) = 5`
c <- `16821 open("rw", O_RDWR|O_NONBLOCK) = 6`
c <- `16821 creat("c", 01) = 6`
}()
r, w := StraceParse3(StraceParse2(c), "")
rok := map[string]bool{
"/etc/ld.so.cache": true,
"r": true,
"rw": true,
}
if !reflect.DeepEqual(r, rok) {
t.Error(r, "!=", rok)
}
wok := map[string]bool{
"w": true,
"c": true,
"rw": true,
}
if !reflect.DeepEqual(w, wok) {
t.Error(w, "!=", wok)
}
}
// Test real applications:
// straceRbase has the base read files for the OS where the tests are run.
var straceRbase map[string]bool
// empty is an empty map
var empty = map[string]bool{}
// filetraceTest is the primitive test function that runs the provided command
// and checks if the set of files read and written match the ones provided.
func filetraceTest(t *testing.T, cmd string, dir string, rok map[string]bool, wok map[string]bool) {
if len(straceRbase) == 0 {
straceRbase, _ = FileTrace("", nil, "")
}
rt, wt := FileTrace(cmd, nil, dir)
rok2 := map[string]bool{}
for r := range rok {
rok2[r] = true
}
for r := range straceRbase {
rok2[r] = true
}
if !reflect.DeepEqual(rt, rok2) {
t.Error("r", rt, "!=", rok2)
}
if !reflect.DeepEqual(wt, wok) {
t.Error("w", wt, "!=", wok)
}
}
// TestFiletraceEchocat is the base test of read/write that runs an echo with the
// output redirected to a file, and a cat that reads that file.
func
|
TestFiletraceEchocat
|
identifier_name
|
|
filetrace_test.go
|
}
// TestStraceParse2Basic tests strace level2 parser by counting parsed entities.
func TestStraceParse2Basic(t *testing.T) {
nopen := 0
nexec := 0
for _, l := range straceout {
if strings.Contains(l, " open(") {
nopen++
}
if strings.Contains(l, " execve(") {
nexec++
}
}
syscalls := map[string]int{}
for info := range StraceParse2(StraceParse1(ChanFromList(straceout))) {
syscalls[info.syscall]++
}
if nopen != syscalls["open"] {
t.Errorf("\"open\" count mismatch: %d != %d", nopen, syscalls["open"])
}
if nexec != syscalls["execve"] {
t.Errorf("\"execve\" count mismatch: %d != %d", nexec, syscalls["execve"])
}
}
// TestStraceParse2Args tests strace level2 argument splitting.
func TestStraceParse2Args(t *testing.T) {
tests := []struct {
str string
ans []string
}{
{"asdf", []string{"asdf"}},
{"as, df", []string{"as", "df"}},
{"a {s, d} f", []string{"a {s, d} f"}},
{"{as, df}", []string{"{as, df}"}},
{`"as, df"`, []string{`"as, df"`}},
{`"as, df", gh`, []string{`"as, df"`, "gh"}},
{`"as, df\", gh"`, []string{`"as, df\", gh"`}},
{`"as, df\""`, []string{`"as, df\""`}},
}
for _, tst := range tests {
a := StraceParse2Argsplit(tst.str)
if !reflect.DeepEqual(a, tst.ans) {
t.Error(a, "!=", tst.ans)
}
}
}
// TestStraceParse2Lines tests a specific line-parsing.
func TestStraceParse2Lines(t *testing.T) {
c := make(chan string)
go func() {
defer close(c)
c <- `16821 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3`
}()
for info := range StraceParse2(c) {
tests := []struct {
ok bool
str string
}{
{info.pid == 16821, "pid mismatch"},
{info.syscall == "open", "syscall mismatch"},
{info.result == 3, "result mismatch"},
{info.body == `"/etc/ld.so.cache", O_RDONLY|O_CLOEXEC`, "body mismatch"},
{info.err == "", "error mismatch"},
}
for _, tst := range tests {
if !tst.ok {
t.Error(tst.str)
}
}
ans := []string{
`"/etc/ld.so.cache"`,
`O_RDONLY|O_CLOEXEC`,
}
if len(ans) != len(info.args) {
t.Errorf("args len mismatch: len(%s)=%d != len(%s)=%d", info.args, len(info.args), ans, len(ans))
}
for i := 0; i < len(info.args); i++ {
if ans[i] != info.args[i] {
t.Errorf("arg %d mismatch", i)
}
}
}
}
// TestStraceParse3 tests StraceParse3 and StraceParse2
func TestStraceParse3(t *testing.T) {
c := make(chan string)
go func() {
defer close(c)
c <- `16821 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3`
c <- `16821 open("w", O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC) = 4`
c <- `16821 open("r", O_RDONLY|O_CLOEXEC) = 5`
c <- `16821 open("rw", O_RDWR|O_NONBLOCK) = 6`
c <- `16821 creat("c", 01) = 6`
}()
r, w := StraceParse3(StraceParse2(c), "")
rok := map[string]bool{
"/etc/ld.so.cache": true,
"r": true,
"rw": true,
}
if !reflect.DeepEqual(r, rok) {
t.Error(r, "!=", rok)
}
wok := map[string]bool{
"w": true,
"c": true,
"rw": true,
}
if !reflect.DeepEqual(w, wok) {
t.Error(w, "!=", wok)
}
}
// Test real applications:
// straceRbase has the base read files for the OS where the tests are run.
var straceRbase map[string]bool
// empty is an empty map
var empty = map[string]bool{}
// filetraceTest is the primitive test function that runs the provided command
// and checks if the set of files read and written match the ones provided.
func filetraceTest(t *testing.T, cmd string, dir string, rok map[string]bool, wok map[string]bool) {
if len(straceRbase) == 0 {
straceRbase, _ = FileTrace("", nil, "")
}
rt, wt := FileTrace(cmd, nil, dir)
rok2 := map[string]bool{}
for r := range rok {
rok2[r] = true
}
for r := range straceRbase {
rok2[r] = true
}
if !reflect.DeepEqual(rt, rok2) {
t.Error("r", rt, "!=", rok2)
}
if !reflect.DeepEqual(wt, wok) {
t.Error("w", wt, "!=", wok)
}
}
// TestFiletraceEchocat is the base test of read/write that runs an echo with the
// output redirected to a file, and a cat that reads that file.
func TestFiletraceEchocat(t *testing.T) {
empty := map[string]bool{}
filetraceTest(t,
"echo asdf > t",
"",
empty,
map[string]bool{"t": true})
defer func() {
if err := os.Remove("t"); err != nil {
t.Error(err)
}
}()
filetraceTest(t,
"cat t > h",
"",
map[string]bool{"t": true},
map[string]bool{"h": true})
defer func() {
if err := os.Remove("h"); err != nil {
t.Error(err)
}
}()
filetraceTest(t,
"cp t j",
"",
map[string]bool{"t": true},
map[string]bool{"j": true})
defer func() {
if err := os.Remove("j"); err != nil {
t.Error(err)
}
}()
}
// TestFiletraceChdir tests directory chaging.
func TestFiletraceChdir(t *testing.T) {
filetraceTest(t,
"mkdir d; cd d; echo asdf > t",
"",
empty,
map[string]bool{"d/t": true})
defer func() {
if err := os.Remove("d/t"); err != nil {
t.Error(err)
}
if err := os.Remove("d"); err != nil {
t.Error(err)
}
}()
}
// TestFiletraceEnv tests the environment argument.
func TestFiletraceEnv(t *testing.T) {
FileTrace("env > e.txt", map[string]string{"x": "y"}, "")
defer func() {
if err := os.Remove("e.txt"); err != nil {
t.Error(err)
}
}()
data, err := ioutil.ReadFile("e.txt")
if err != nil {
t.Fatal(err)
}
datastr := string(data)
if !strings.Contains(datastr, "x=y") {
t.Fatalf("environment x=y not found in %s", datastr)
}
}
// TestFiletraceDir tests the dir argument.
func TestFiletraceDir(t *testing.T) {
os.Mkdir("d", 0755)
filetraceTest(t,
"mkdir -p s/ss; cd s; cd ss; echo asdf > t; echo zxcv > z; rm z",
"d",
empty,
map[string]bool{"s/ss/t": true})
defer func() {
for _, f := range []string{"d/s/ss/t", "d/s/ss", "d/s", "d"} {
if err := os.Remove(f); err != nil {
t.Error(err)
}
}
}()
}
// TestFiletraceRename tests renaming
func TestFiletraceRename(t *testing.T)
|
{
empty := map[string]bool{}
filetraceTest(t,
"echo asdf > t; mv t v",
"",
empty,
map[string]bool{"v": true})
defer func() {
if err := os.Remove("v"); err != nil {
t.Error(err)
}
}()
}
|
identifier_body
|
|
filetrace_test.go
|
([]string, 0, len(straceout))
for l := range StraceParse1(ChanFromList(straceout)) {
if strings.Contains(l, "resumed") || strings.Contains(l, "finished") {
t.Error("found invalid string in parsed results: " + l)
}
parsed = append(parsed, l)
}
if len(parsed) != n {
t.Error("incorrect len of parsed strings")
}
}
// TestStraceParse2Basic tests strace level2 parser by counting parsed entities.
func TestStraceParse2Basic(t *testing.T) {
nopen := 0
nexec := 0
for _, l := range straceout {
if strings.Contains(l, " open(") {
nopen++
}
if strings.Contains(l, " execve(") {
nexec++
}
}
syscalls := map[string]int{}
for info := range StraceParse2(StraceParse1(ChanFromList(straceout))) {
syscalls[info.syscall]++
}
if nopen != syscalls["open"] {
t.Errorf("\"open\" count mismatch: %d != %d", nopen, syscalls["open"])
}
if nexec != syscalls["execve"] {
t.Errorf("\"execve\" count mismatch: %d != %d", nexec, syscalls["execve"])
}
}
// TestStraceParse2Args tests strace level2 argument splitting.
func TestStraceParse2Args(t *testing.T) {
tests := []struct {
str string
ans []string
}{
{"asdf", []string{"asdf"}},
{"as, df", []string{"as", "df"}},
{"a {s, d} f", []string{"a {s, d} f"}},
{"{as, df}", []string{"{as, df}"}},
{`"as, df"`, []string{`"as, df"`}},
{`"as, df", gh`, []string{`"as, df"`, "gh"}},
{`"as, df\", gh"`, []string{`"as, df\", gh"`}},
{`"as, df\""`, []string{`"as, df\""`}},
}
for _, tst := range tests {
a := StraceParse2Argsplit(tst.str)
if !reflect.DeepEqual(a, tst.ans) {
t.Error(a, "!=", tst.ans)
}
}
}
// TestStraceParse2Lines tests a specific line-parsing.
func TestStraceParse2Lines(t *testing.T) {
c := make(chan string)
go func() {
defer close(c)
c <- `16821 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3`
}()
for info := range StraceParse2(c) {
tests := []struct {
ok bool
str string
}{
{info.pid == 16821, "pid mismatch"},
{info.syscall == "open", "syscall mismatch"},
{info.result == 3, "result mismatch"},
{info.body == `"/etc/ld.so.cache", O_RDONLY|O_CLOEXEC`, "body mismatch"},
{info.err == "", "error mismatch"},
}
for _, tst := range tests {
if !tst.ok {
t.Error(tst.str)
}
}
ans := []string{
`"/etc/ld.so.cache"`,
`O_RDONLY|O_CLOEXEC`,
}
if len(ans) != len(info.args) {
t.Errorf("args len mismatch: len(%s)=%d != len(%s)=%d", info.args, len(info.args), ans, len(ans))
}
for i := 0; i < len(info.args); i++ {
if ans[i] != info.args[i] {
t.Errorf("arg %d mismatch", i)
}
}
}
}
// TestStraceParse3 tests StraceParse3 and StraceParse2
func TestStraceParse3(t *testing.T) {
c := make(chan string)
go func() {
defer close(c)
c <- `16821 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3`
c <- `16821 open("w", O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC) = 4`
c <- `16821 open("r", O_RDONLY|O_CLOEXEC) = 5`
c <- `16821 open("rw", O_RDWR|O_NONBLOCK) = 6`
c <- `16821 creat("c", 01) = 6`
}()
r, w := StraceParse3(StraceParse2(c), "")
rok := map[string]bool{
"/etc/ld.so.cache": true,
"r": true,
"rw": true,
}
if !reflect.DeepEqual(r, rok) {
t.Error(r, "!=", rok)
}
wok := map[string]bool{
"w": true,
"c": true,
"rw": true,
}
if !reflect.DeepEqual(w, wok) {
t.Error(w, "!=", wok)
}
}
// Test real applications:
// straceRbase has the base read files for the OS where the tests are run.
var straceRbase map[string]bool
// empty is an empty map
var empty = map[string]bool{}
// filetraceTest is the primitive test function that runs the provided command
// and checks if the set of files read and written match the ones provided.
func filetraceTest(t *testing.T, cmd string, dir string, rok map[string]bool, wok map[string]bool) {
if len(straceRbase) == 0 {
straceRbase, _ = FileTrace("", nil, "")
}
rt, wt := FileTrace(cmd, nil, dir)
rok2 := map[string]bool{}
for r := range rok {
rok2[r] = true
}
for r := range straceRbase {
rok2[r] = true
}
if !reflect.DeepEqual(rt, rok2) {
t.Error("r", rt, "!=", rok2)
}
if !reflect.DeepEqual(wt, wok) {
t.Error("w", wt, "!=", wok)
}
}
// TestFiletraceEchocat is the base test of read/write that runs an echo with the
// output redirected to a file, and a cat that reads that file.
func TestFiletraceEchocat(t *testing.T) {
empty := map[string]bool{}
filetraceTest(t,
"echo asdf > t",
"",
empty,
map[string]bool{"t": true})
defer func() {
if err := os.Remove("t"); err != nil {
t.Error(err)
}
}()
filetraceTest(t,
"cat t > h",
"",
map[string]bool{"t": true},
map[string]bool{"h": true})
defer func() {
if err := os.Remove("h"); err != nil {
t.Error(err)
}
}()
filetraceTest(t,
"cp t j",
"",
map[string]bool{"t": true},
map[string]bool{"j": true})
defer func() {
if err := os.Remove("j"); err != nil {
t.Error(err)
}
}()
}
// TestFiletraceChdir tests directory chaging.
func TestFiletraceChdir(t *testing.T) {
filetraceTest(t,
"mkdir d; cd d; echo asdf > t",
"",
empty,
map[string]bool{"d/t": true})
defer func() {
if err := os.Remove("d/t"); err != nil {
t.Error(err)
}
if err := os.Remove("d"); err != nil {
t.Error(err)
}
}()
}
// TestFiletraceEnv tests the environment argument.
func TestFiletraceEnv(t *testing.T) {
FileTrace("env > e.txt", map[string]string{"x": "y"}, "")
defer func() {
if err := os.Remove("e.txt"); err != nil {
t.Error(err)
}
}()
data, err := ioutil.ReadFile("e.txt")
if err != nil {
t.Fatal(err)
}
datastr := string(data)
if !strings.Contains(datastr, "x=y") {
t.Fatalf("environment x=y not found in %s", datastr)
}
}
// TestFiletraceDir tests the dir argument.
func TestFiletraceDir(t *testing.T) {
os.Mkdir("d", 0755)
filetraceTest(t,
"mkdir -p s/ss; cd s; cd ss; echo asdf > t; echo zxcv > z; rm z",
"d",
empty,
map[string]bool{"s/ss/t": true})
defer func() {
for _, f := range []string{"d/s/ss/t", "d/s/ss", "d/s", "d"} {
|
if err := os.Remove(f); err != nil {
t.Error(err)
}
|
random_line_split
|
|
settings.py
|
return git_hash.rstrip()
root = environ.Path(__file__) - 2 # two levels back in hierarchy
env = environ.Env(
DEBUG=(bool, False),
DJANGO_LOG_LEVEL=(str, "INFO"),
CONN_MAX_AGE=(int, 0),
SYSTEM_DATA_SOURCE_ID=(str, "hauki"),
LANGUAGES=(list, ["fi", "sv", "en"]),
DATABASE_URL=(str, "postgres:///hauki"),
TEST_DATABASE_URL=(str, ""),
TOKEN_AUTH_ACCEPTED_AUDIENCE=(str, ""),
TOKEN_AUTH_SHARED_SECRET=(str, ""),
SECRET_KEY=(str, ""),
ALLOWED_HOSTS=(list, []),
ADMINS=(list, []),
SECURE_PROXY_SSL_HEADER=(tuple, None),
MEDIA_ROOT=(environ.Path(), root("media")),
STATIC_ROOT=(environ.Path(), root("static")),
MEDIA_URL=(str, "/media/"),
STATIC_URL=(str, "/static/"),
TRUST_X_FORWARDED_HOST=(bool, False),
SENTRY_DSN=(str, ""),
SENTRY_ENVIRONMENT=(str, "development"),
COOKIE_PREFIX=(str, "hauki"),
INTERNAL_IPS=(list, []),
INSTANCE_NAME=(str, "Hauki"),
EXTRA_INSTALLED_APPS=(list, []),
ENABLE_DJANGO_EXTENSIONS=(bool, False),
MAIL_MAILGUN_KEY=(str, ""),
MAIL_MAILGUN_DOMAIN=(str, ""),
MAIL_MAILGUN_API=(str, ""),
RESOURCE_DEFAULT_TIMEZONE=(str, None),
)
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = root()
# Django environ has a nasty habit of complanining at level
# WARN about env file not being preset. Here we pre-empt it.
env_file_path = os.path.join(BASE_DIR, CONFIG_FILE_NAME)
if os.path.exists(env_file_path):
# Logging configuration is not available at this point
print(f"Reading config from {env_file_path}")
environ.Env.read_env(env_file_path)
DEBUG = env("DEBUG")
TEMPLATE_DEBUG = False
ALLOWED_HOSTS = env("ALLOWED_HOSTS")
ADMINS = env("ADMINS")
INTERNAL_IPS = env("INTERNAL_IPS", default=(["127.0.0.1"] if DEBUG else []))
DATABASES = {"default": env.db()}
DATABASES["default"]["CONN_MAX_AGE"] = env("CONN_MAX_AGE")
if env("TEST_DATABASE_URL"):
DATABASES["default"]["TEST"] = env.db("TEST_DATABASE_URL")
DEFAULT_AUTO_FIELD = "django.db.models.AutoField"
AUTH_USER_MODEL = "users.User"
LOGIN_URL = "/login/"
LOGIN_REDIRECT_URL = "/v1/"
LOGOUT_REDIRECT_URL = "/v1/"
RESOURCE_DEFAULT_TIMEZONE = env("RESOURCE_DEFAULT_TIMEZONE")
DJANGO_ORGHIERARCHY_DATASOURCE_MODEL = "hours.DataSource"
SYSTEM_DATA_SOURCE_ID = env("SYSTEM_DATA_SOURCE_ID")
SITE_ID = 1
LOGGING = {
"version": 1,
"disable_existing_loggers": False,
"formatters": {
"timestamped_named": {
"format": "%(asctime)s %(name)s %(levelname)s: %(message)s",
},
},
"handlers": {
"console": {
"class": "logging.StreamHandler",
"formatter": "timestamped_named",
},
# Just for reference, not used
"blackhole": {
"class": "logging.NullHandler",
},
},
"loggers": {
"": {
"handlers": ["console"],
"level": os.getenv("DJANGO_LOG_LEVEL", "INFO"),
},
"django": {
"handlers": ["console"],
"level": os.getenv("DJANGO_LOG_LEVEL", "INFO"),
},
},
}
# Application definition
INSTALLED_APPS = [
"helusers.apps.HelusersConfig",
"modeltranslation",
"helusers.apps.HelusersAdminConfig",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.humanize",
"simple_history",
# disable Django’s development server static file handling
"whitenoise.runserver_nostatic",
"django.contrib.staticfiles",
"rest_framework",
"rest_framework.authtoken",
"django_filters",
"django_orghierarchy",
"timezone_field",
"mptt",
# Apps within this repository
"users",
"hours",
# OpenAPI
"drf_spectacular",
] + env("EXTRA_INSTALLED_APPS")
if env("SENTRY_DSN"):
sentry_sdk.init(
dsn=env("SENTRY_DSN"),
environment=env("SENTRY_ENVIRONMENT"),
release=get_git_revision_hash(),
integrations=[DjangoIntegration()],
)
MIDDLEWARE = [
# CorsMiddleware should be placed as high as possible and above WhiteNoiseMiddleware
# in particular
"corsheaders.middleware.CorsMiddleware",
# Ditto for securitymiddleware
"django.middleware.security.SecurityMiddleware",
"whitenoise.middleware.WhiteNoiseMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
"simple_history.middleware.HistoryRequestMiddleware",
]
# django-extensions is a set of developer friendly tools
if env("ENABLE_DJANGO_EXTENSIONS"):
INSTALLED_APPS.append("django_extensions")
ROOT_URLCONF = "hauki.urls"
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
],
},
},
]
WSGI_APPLICATION = "hauki.wsgi.application"
# Password validation
# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
"NAME": "django.contrib.auth.password_validation."
"UserAttributeSimilarityValidator",
},
{
"NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
},
{
"NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
},
{
"NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.0/topics/i18n/
# Map language codes to the (code, name) tuples used by Django
# We want to keep the ordering in LANGUAGES configuration variable,
# thus some gyrations
language_map = {x: y for x, y in GLOBAL_LANGUAGES}
try:
LANGUAGES = tuple((lang, language_map[lang]) for lang in env("LANGUAGES"))
except KeyError as e:
raise ImproperlyConfigured(f'unknown language code "{e.args[0]}"')
LANGUAGE_CODE = env("LANGUAGES")[0]
TIME_ZONE = "Europe/Helsinki"
USE_I18N = True
USE_L10N = True
USE_TZ = True
LOCALE_PATHS = [root("locale")]
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.0/howto/static-files/
STATIC_URL = env("STATIC_URL")
MEDIA_URL = env("MEDIA_URL")
STATIC_ROOT = env("STATIC_ROOT")
MEDIA_ROOT = env("MEDIA_ROOT")
# Whether to trust X-Forwarded-Host headers for all purposes
# where Django would need to make use of its own hostname
# fe. generating absolute URLs pointing to itself
# Most often used in reverse proxy setups
# https://docs.djangoproject.com/en/3.0/ref/settings/#use-x-forwarded-host
USE_X_FORWARDED_HOST = env("TRUST_X_FORWARDED_HOST")
# Specifies a header that is trusted to indicate that the request was using
# https while traversing over the Internet at large. This is used when
# a proxy terminates the TLS connection and forwards the request over
# a secure network. Specified using a tuple.
# https://docs.djangoproject.com/en/3.0/ref/settings/#secure-proxy-ssl-header
SECURE_PROXY_SSL_HEADER = env("SECURE_PROXY_SSL_HEADER")
CORS_ORIGIN_ALLOW_ALL = True
CSRF_COOKIE_NAME = "%s-csrftoken" % env("COOKIE_PREFIX")
SESSION_COOKIE_NAME = "%s-sessionid" % env("COOKIE_PREFIX")
# DRF Settings
# https://www.django-rest-framework.org/api-guide/settings/
REST
|
"""
Retrieve the git hash for the underlying git repository or die trying
We need a way to retrieve git revision hash for sentry reports
I assume that if we have a git repository available we will
have git-the-comamand as well
"""
try:
# We are not interested in gits complaints
git_hash = subprocess.check_output(
["git", "rev-parse", "HEAD"], stderr=subprocess.DEVNULL, encoding="utf8"
)
# ie. "git" was not found
# should we return a more generic meta hash here?
# like "undefined"?
except FileNotFoundError:
git_hash = "git_not_available"
except subprocess.CalledProcessError:
# Ditto
git_hash = "no_repository"
|
identifier_body
|
|
settings.py
|
except FileNotFoundError:
git_hash = "git_not_available"
except subprocess.CalledProcessError:
# Ditto
git_hash = "no_repository"
return git_hash.rstrip()
root = environ.Path(__file__) - 2 # two levels back in hierarchy
env = environ.Env(
DEBUG=(bool, False),
DJANGO_LOG_LEVEL=(str, "INFO"),
CONN_MAX_AGE=(int, 0),
SYSTEM_DATA_SOURCE_ID=(str, "hauki"),
LANGUAGES=(list, ["fi", "sv", "en"]),
DATABASE_URL=(str, "postgres:///hauki"),
TEST_DATABASE_URL=(str, ""),
TOKEN_AUTH_ACCEPTED_AUDIENCE=(str, ""),
TOKEN_AUTH_SHARED_SECRET=(str, ""),
SECRET_KEY=(str, ""),
ALLOWED_HOSTS=(list, []),
ADMINS=(list, []),
SECURE_PROXY_SSL_HEADER=(tuple, None),
MEDIA_ROOT=(environ.Path(), root("media")),
STATIC_ROOT=(environ.Path(), root("static")),
MEDIA_URL=(str, "/media/"),
STATIC_URL=(str, "/static/"),
TRUST_X_FORWARDED_HOST=(bool, False),
SENTRY_DSN=(str, ""),
SENTRY_ENVIRONMENT=(str, "development"),
COOKIE_PREFIX=(str, "hauki"),
INTERNAL_IPS=(list, []),
INSTANCE_NAME=(str, "Hauki"),
EXTRA_INSTALLED_APPS=(list, []),
ENABLE_DJANGO_EXTENSIONS=(bool, False),
MAIL_MAILGUN_KEY=(str, ""),
MAIL_MAILGUN_DOMAIN=(str, ""),
MAIL_MAILGUN_API=(str, ""),
RESOURCE_DEFAULT_TIMEZONE=(str, None),
)
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = root()
# Django environ has a nasty habit of complanining at level
# WARN about env file not being preset. Here we pre-empt it.
env_file_path = os.path.join(BASE_DIR, CONFIG_FILE_NAME)
if os.path.exists(env_file_path):
# Logging configuration is not available at this point
print(f"Reading config from {env_file_path}")
environ.Env.read_env(env_file_path)
DEBUG = env("DEBUG")
TEMPLATE_DEBUG = False
ALLOWED_HOSTS = env("ALLOWED_HOSTS")
ADMINS = env("ADMINS")
INTERNAL_IPS = env("INTERNAL_IPS", default=(["127.0.0.1"] if DEBUG else []))
DATABASES = {"default": env.db()}
DATABASES["default"]["CONN_MAX_AGE"] = env("CONN_MAX_AGE")
if env("TEST_DATABASE_URL"):
DATABASES["default"]["TEST"] = env.db("TEST_DATABASE_URL")
DEFAULT_AUTO_FIELD = "django.db.models.AutoField"
AUTH_USER_MODEL = "users.User"
LOGIN_URL = "/login/"
LOGIN_REDIRECT_URL = "/v1/"
LOGOUT_REDIRECT_URL = "/v1/"
RESOURCE_DEFAULT_TIMEZONE = env("RESOURCE_DEFAULT_TIMEZONE")
DJANGO_ORGHIERARCHY_DATASOURCE_MODEL = "hours.DataSource"
SYSTEM_DATA_SOURCE_ID = env("SYSTEM_DATA_SOURCE_ID")
SITE_ID = 1
LOGGING = {
"version": 1,
"disable_existing_loggers": False,
"formatters": {
"timestamped_named": {
"format": "%(asctime)s %(name)s %(levelname)s: %(message)s",
},
},
"handlers": {
"console": {
"class": "logging.StreamHandler",
"formatter": "timestamped_named",
},
# Just for reference, not used
"blackhole": {
"class": "logging.NullHandler",
},
},
"loggers": {
"": {
"handlers": ["console"],
"level": os.getenv("DJANGO_LOG_LEVEL", "INFO"),
},
"django": {
"handlers": ["console"],
"level": os.getenv("DJANGO_LOG_LEVEL", "INFO"),
},
},
}
# Application definition
INSTALLED_APPS = [
"helusers.apps.HelusersConfig",
"modeltranslation",
"helusers.apps.HelusersAdminConfig",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.humanize",
"simple_history",
# disable Django’s development server static file handling
"whitenoise.runserver_nostatic",
"django.contrib.staticfiles",
"rest_framework",
"rest_framework.authtoken",
"django_filters",
"django_orghierarchy",
"timezone_field",
"mptt",
# Apps within this repository
"users",
"hours",
# OpenAPI
"drf_spectacular",
] + env("EXTRA_INSTALLED_APPS")
if env("SENTRY_DSN"):
se
|
MIDDLEWARE = [
# CorsMiddleware should be placed as high as possible and above WhiteNoiseMiddleware
# in particular
"corsheaders.middleware.CorsMiddleware",
# Ditto for securitymiddleware
"django.middleware.security.SecurityMiddleware",
"whitenoise.middleware.WhiteNoiseMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
"simple_history.middleware.HistoryRequestMiddleware",
]
# django-extensions is a set of developer friendly tools
if env("ENABLE_DJANGO_EXTENSIONS"):
INSTALLED_APPS.append("django_extensions")
ROOT_URLCONF = "hauki.urls"
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
],
},
},
]
WSGI_APPLICATION = "hauki.wsgi.application"
# Password validation
# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
"NAME": "django.contrib.auth.password_validation."
"UserAttributeSimilarityValidator",
},
{
"NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
},
{
"NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
},
{
"NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.0/topics/i18n/
# Map language codes to the (code, name) tuples used by Django
# We want to keep the ordering in LANGUAGES configuration variable,
# thus some gyrations
language_map = {x: y for x, y in GLOBAL_LANGUAGES}
try:
LANGUAGES = tuple((lang, language_map[lang]) for lang in env("LANGUAGES"))
except KeyError as e:
raise ImproperlyConfigured(f'unknown language code "{e.args[0]}"')
LANGUAGE_CODE = env("LANGUAGES")[0]
TIME_ZONE = "Europe/Helsinki"
USE_I18N = True
USE_L10N = True
USE_TZ = True
LOCALE_PATHS = [root("locale")]
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.0/howto/static-files/
STATIC_URL = env("STATIC_URL")
MEDIA_URL = env("MEDIA_URL")
STATIC_ROOT = env("STATIC_ROOT")
MEDIA_ROOT = env("MEDIA_ROOT")
# Whether to trust X-Forwarded-Host headers for all purposes
# where Django would need to make use of its own hostname
# fe. generating absolute URLs pointing to itself
# Most often used in reverse proxy setups
# https://docs.djangoproject.com/en/3.0/ref/settings/#use-x-forwarded-host
USE_X_FORWARDED_HOST = env("TRUST_X_FORWARDED_HOST")
# Specifies a header that is trusted to indicate that the request was using
# https while traversing over the Internet at large. This is used when
# a proxy terminates the TLS connection and forwards the request over
# a secure network. Specified using a tuple.
# https://docs.djangoproject.com/en/3.0/ref/settings/#secure-proxy-ssl-header
SECURE_PROXY_SSL_HEADER = env("SECURE_PROXY_SSL_HEADER")
CORS_ORIGIN_ALLOW_ALL = True
CSRF_COOKIE_NAME = "%s-csrftoken" % env("COOKIE_PREFIX")
SESSION_COOKIE_NAME = "%s-sessionid" % env("COOKIE_PREFIX")
# DRF Settings
# https://www.django-rest-framework.org/api-guide/settings/
REST_FRAMEWORK = {
"DEFAULT_RENDERER_CLASSES": [
"rest_framework.renderers.JSONRenderer",
"hours.renderers.BrowsableAPIRendererWithoutForms",
],
"DEFAULT_FILTER_BACKENDS": [
"rest_framework.filters.OrderingFilter",
"django_filters.rest_framework.DjangoFilterBackend",
],
"DEFAULT_AUTHENTICATION_CLASSES": [
"hours.authentication.HaukiSignedAuthentication",
"hours.authentication.HaukiTokenAuthentication",
"rest_framework.authentication.SessionAuthentication",
],
"DEFAULT_PERMISSION_CLASSES": [
"rest_framework.permissions.IsAuthenticatedOrReadOnly",
],
"DEFAULT_METADATA_CLASS": "hours.metadata.Trans
|
ntry_sdk.init(
dsn=env("SENTRY_DSN"),
environment=env("SENTRY_ENVIRONMENT"),
release=get_git_revision_hash(),
integrations=[DjangoIntegration()],
)
|
conditional_block
|
settings.py
|
except FileNotFoundError:
git_hash = "git_not_available"
except subprocess.CalledProcessError:
# Ditto
git_hash = "no_repository"
return git_hash.rstrip()
root = environ.Path(__file__) - 2 # two levels back in hierarchy
env = environ.Env(
DEBUG=(bool, False),
DJANGO_LOG_LEVEL=(str, "INFO"),
CONN_MAX_AGE=(int, 0),
SYSTEM_DATA_SOURCE_ID=(str, "hauki"),
LANGUAGES=(list, ["fi", "sv", "en"]),
DATABASE_URL=(str, "postgres:///hauki"),
TEST_DATABASE_URL=(str, ""),
TOKEN_AUTH_ACCEPTED_AUDIENCE=(str, ""),
TOKEN_AUTH_SHARED_SECRET=(str, ""),
SECRET_KEY=(str, ""),
ALLOWED_HOSTS=(list, []),
ADMINS=(list, []),
SECURE_PROXY_SSL_HEADER=(tuple, None),
MEDIA_ROOT=(environ.Path(), root("media")),
STATIC_ROOT=(environ.Path(), root("static")),
MEDIA_URL=(str, "/media/"),
STATIC_URL=(str, "/static/"),
TRUST_X_FORWARDED_HOST=(bool, False),
SENTRY_DSN=(str, ""),
SENTRY_ENVIRONMENT=(str, "development"),
COOKIE_PREFIX=(str, "hauki"),
INTERNAL_IPS=(list, []),
INSTANCE_NAME=(str, "Hauki"),
EXTRA_INSTALLED_APPS=(list, []),
ENABLE_DJANGO_EXTENSIONS=(bool, False),
MAIL_MAILGUN_KEY=(str, ""),
MAIL_MAILGUN_DOMAIN=(str, ""),
MAIL_MAILGUN_API=(str, ""),
RESOURCE_DEFAULT_TIMEZONE=(str, None),
)
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = root()
# Django environ has a nasty habit of complanining at level
# WARN about env file not being preset. Here we pre-empt it.
env_file_path = os.path.join(BASE_DIR, CONFIG_FILE_NAME)
if os.path.exists(env_file_path):
# Logging configuration is not available at this point
print(f"Reading config from {env_file_path}")
environ.Env.read_env(env_file_path)
DEBUG = env("DEBUG")
TEMPLATE_DEBUG = False
ALLOWED_HOSTS = env("ALLOWED_HOSTS")
ADMINS = env("ADMINS")
INTERNAL_IPS = env("INTERNAL_IPS", default=(["127.0.0.1"] if DEBUG else []))
DATABASES = {"default": env.db()}
DATABASES["default"]["CONN_MAX_AGE"] = env("CONN_MAX_AGE")
if env("TEST_DATABASE_URL"):
DATABASES["default"]["TEST"] = env.db("TEST_DATABASE_URL")
DEFAULT_AUTO_FIELD = "django.db.models.AutoField"
AUTH_USER_MODEL = "users.User"
LOGIN_URL = "/login/"
LOGIN_REDIRECT_URL = "/v1/"
LOGOUT_REDIRECT_URL = "/v1/"
RESOURCE_DEFAULT_TIMEZONE = env("RESOURCE_DEFAULT_TIMEZONE")
DJANGO_ORGHIERARCHY_DATASOURCE_MODEL = "hours.DataSource"
SYSTEM_DATA_SOURCE_ID = env("SYSTEM_DATA_SOURCE_ID")
SITE_ID = 1
LOGGING = {
"version": 1,
"disable_existing_loggers": False,
"formatters": {
"timestamped_named": {
"format": "%(asctime)s %(name)s %(levelname)s: %(message)s",
},
},
"handlers": {
"console": {
"class": "logging.StreamHandler",
"formatter": "timestamped_named",
},
# Just for reference, not used
"blackhole": {
"class": "logging.NullHandler",
},
},
"loggers": {
"": {
"handlers": ["console"],
"level": os.getenv("DJANGO_LOG_LEVEL", "INFO"),
},
"django": {
"handlers": ["console"],
"level": os.getenv("DJANGO_LOG_LEVEL", "INFO"),
},
},
}
# Application definition
INSTALLED_APPS = [
"helusers.apps.HelusersConfig",
"modeltranslation",
"helusers.apps.HelusersAdminConfig",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.humanize",
"simple_history",
# disable Django’s development server static file handling
"whitenoise.runserver_nostatic",
"django.contrib.staticfiles",
"rest_framework",
"rest_framework.authtoken",
"django_filters",
"django_orghierarchy",
"timezone_field",
"mptt",
# Apps within this repository
"users",
"hours",
# OpenAPI
"drf_spectacular",
] + env("EXTRA_INSTALLED_APPS")
if env("SENTRY_DSN"):
sentry_sdk.init(
dsn=env("SENTRY_DSN"),
environment=env("SENTRY_ENVIRONMENT"),
release=get_git_revision_hash(),
integrations=[DjangoIntegration()],
)
MIDDLEWARE = [
# CorsMiddleware should be placed as high as possible and above WhiteNoiseMiddleware
# in particular
"corsheaders.middleware.CorsMiddleware",
# Ditto for securitymiddleware
"django.middleware.security.SecurityMiddleware",
"whitenoise.middleware.WhiteNoiseMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
"simple_history.middleware.HistoryRequestMiddleware",
]
# django-extensions is a set of developer friendly tools
if env("ENABLE_DJANGO_EXTENSIONS"):
INSTALLED_APPS.append("django_extensions")
ROOT_URLCONF = "hauki.urls"
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
],
},
},
]
WSGI_APPLICATION = "hauki.wsgi.application"
# Password validation
# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
"NAME": "django.contrib.auth.password_validation."
"UserAttributeSimilarityValidator",
},
{
"NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
},
{
"NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
},
{
"NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.0/topics/i18n/
# Map language codes to the (code, name) tuples used by Django
# We want to keep the ordering in LANGUAGES configuration variable,
# thus some gyrations
language_map = {x: y for x, y in GLOBAL_LANGUAGES}
try:
LANGUAGES = tuple((lang, language_map[lang]) for lang in env("LANGUAGES"))
except KeyError as e:
raise ImproperlyConfigured(f'unknown language code "{e.args[0]}"')
LANGUAGE_CODE = env("LANGUAGES")[0]
TIME_ZONE = "Europe/Helsinki"
USE_I18N = True
USE_L10N = True
USE_TZ = True
LOCALE_PATHS = [root("locale")]
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.0/howto/static-files/
|
STATIC_ROOT = env("STATIC_ROOT")
MEDIA_ROOT = env("MEDIA_ROOT")
# Whether to trust X-Forwarded-Host headers for all purposes
# where Django would need to make use of its own hostname
# fe. generating absolute URLs pointing to itself
# Most often used in reverse proxy setups
# https://docs.djangoproject.com/en/3.0/ref/settings/#use-x-forwarded-host
USE_X_FORWARDED_HOST = env("TRUST_X_FORWARDED_HOST")
# Specifies a header that is trusted to indicate that the request was using
# https while traversing over the Internet at large. This is used when
# a proxy terminates the TLS connection and forwards the request over
# a secure network. Specified using a tuple.
# https://docs.djangoproject.com/en/3.0/ref/settings/#secure-proxy-ssl-header
SECURE_PROXY_SSL_HEADER = env("SECURE_PROXY_SSL_HEADER")
CORS_ORIGIN_ALLOW_ALL = True
CSRF_COOKIE_NAME = "%s-csrftoken" % env("COOKIE_PREFIX")
SESSION_COOKIE_NAME = "%s-sessionid" % env("COOKIE_PREFIX")
# DRF Settings
# https://www.django-rest-framework.org/api-guide/settings/
REST_FRAMEWORK = {
"DEFAULT_RENDERER_CLASSES": [
"rest_framework.renderers.JSONRenderer",
"hours.renderers.BrowsableAPIRendererWithoutForms",
],
"DEFAULT_FILTER_BACKENDS": [
"rest_framework.filters.OrderingFilter",
"django_filters.rest_framework.DjangoFilterBackend",
],
"DEFAULT_AUTHENTICATION_CLASSES": [
"hours.authentication.HaukiSignedAuthentication",
"hours.authentication.HaukiTokenAuthentication",
"rest_framework.authentication.SessionAuthentication",
],
"DEFAULT_PERMISSION_CLASSES": [
"rest_framework.permissions.IsAuthenticatedOrReadOnly",
],
"DEFAULT_METADATA_CLASS": "hours.metadata.Trans
|
STATIC_URL = env("STATIC_URL")
MEDIA_URL = env("MEDIA_URL")
|
random_line_split
|
settings.py
|
() -> str:
"""
Retrieve the git hash for the underlying git repository or die trying
We need a way to retrieve git revision hash for sentry reports
I assume that if we have a git repository available we will
have git-the-comamand as well
"""
try:
# We are not interested in gits complaints
git_hash = subprocess.check_output(
["git", "rev-parse", "HEAD"], stderr=subprocess.DEVNULL, encoding="utf8"
)
# ie. "git" was not found
# should we return a more generic meta hash here?
# like "undefined"?
except FileNotFoundError:
git_hash = "git_not_available"
except subprocess.CalledProcessError:
# Ditto
git_hash = "no_repository"
return git_hash.rstrip()
root = environ.Path(__file__) - 2 # two levels back in hierarchy
env = environ.Env(
DEBUG=(bool, False),
DJANGO_LOG_LEVEL=(str, "INFO"),
CONN_MAX_AGE=(int, 0),
SYSTEM_DATA_SOURCE_ID=(str, "hauki"),
LANGUAGES=(list, ["fi", "sv", "en"]),
DATABASE_URL=(str, "postgres:///hauki"),
TEST_DATABASE_URL=(str, ""),
TOKEN_AUTH_ACCEPTED_AUDIENCE=(str, ""),
TOKEN_AUTH_SHARED_SECRET=(str, ""),
SECRET_KEY=(str, ""),
ALLOWED_HOSTS=(list, []),
ADMINS=(list, []),
SECURE_PROXY_SSL_HEADER=(tuple, None),
MEDIA_ROOT=(environ.Path(), root("media")),
STATIC_ROOT=(environ.Path(), root("static")),
MEDIA_URL=(str, "/media/"),
STATIC_URL=(str, "/static/"),
TRUST_X_FORWARDED_HOST=(bool, False),
SENTRY_DSN=(str, ""),
SENTRY_ENVIRONMENT=(str, "development"),
COOKIE_PREFIX=(str, "hauki"),
INTERNAL_IPS=(list, []),
INSTANCE_NAME=(str, "Hauki"),
EXTRA_INSTALLED_APPS=(list, []),
ENABLE_DJANGO_EXTENSIONS=(bool, False),
MAIL_MAILGUN_KEY=(str, ""),
MAIL_MAILGUN_DOMAIN=(str, ""),
MAIL_MAILGUN_API=(str, ""),
RESOURCE_DEFAULT_TIMEZONE=(str, None),
)
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = root()
# Django environ has a nasty habit of complanining at level
# WARN about env file not being preset. Here we pre-empt it.
env_file_path = os.path.join(BASE_DIR, CONFIG_FILE_NAME)
if os.path.exists(env_file_path):
# Logging configuration is not available at this point
print(f"Reading config from {env_file_path}")
environ.Env.read_env(env_file_path)
DEBUG = env("DEBUG")
TEMPLATE_DEBUG = False
ALLOWED_HOSTS = env("ALLOWED_HOSTS")
ADMINS = env("ADMINS")
INTERNAL_IPS = env("INTERNAL_IPS", default=(["127.0.0.1"] if DEBUG else []))
DATABASES = {"default": env.db()}
DATABASES["default"]["CONN_MAX_AGE"] = env("CONN_MAX_AGE")
if env("TEST_DATABASE_URL"):
DATABASES["default"]["TEST"] = env.db("TEST_DATABASE_URL")
DEFAULT_AUTO_FIELD = "django.db.models.AutoField"
AUTH_USER_MODEL = "users.User"
LOGIN_URL = "/login/"
LOGIN_REDIRECT_URL = "/v1/"
LOGOUT_REDIRECT_URL = "/v1/"
RESOURCE_DEFAULT_TIMEZONE = env("RESOURCE_DEFAULT_TIMEZONE")
DJANGO_ORGHIERARCHY_DATASOURCE_MODEL = "hours.DataSource"
SYSTEM_DATA_SOURCE_ID = env("SYSTEM_DATA_SOURCE_ID")
SITE_ID = 1
LOGGING = {
"version": 1,
"disable_existing_loggers": False,
"formatters": {
"timestamped_named": {
"format": "%(asctime)s %(name)s %(levelname)s: %(message)s",
},
},
"handlers": {
"console": {
"class": "logging.StreamHandler",
"formatter": "timestamped_named",
},
# Just for reference, not used
"blackhole": {
"class": "logging.NullHandler",
},
},
"loggers": {
"": {
"handlers": ["console"],
"level": os.getenv("DJANGO_LOG_LEVEL", "INFO"),
},
"django": {
"handlers": ["console"],
"level": os.getenv("DJANGO_LOG_LEVEL", "INFO"),
},
},
}
# Application definition
INSTALLED_APPS = [
"helusers.apps.HelusersConfig",
"modeltranslation",
"helusers.apps.HelusersAdminConfig",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.humanize",
"simple_history",
# disable Django’s development server static file handling
"whitenoise.runserver_nostatic",
"django.contrib.staticfiles",
"rest_framework",
"rest_framework.authtoken",
"django_filters",
"django_orghierarchy",
"timezone_field",
"mptt",
# Apps within this repository
"users",
"hours",
# OpenAPI
"drf_spectacular",
] + env("EXTRA_INSTALLED_APPS")
if env("SENTRY_DSN"):
sentry_sdk.init(
dsn=env("SENTRY_DSN"),
environment=env("SENTRY_ENVIRONMENT"),
release=get_git_revision_hash(),
integrations=[DjangoIntegration()],
)
MIDDLEWARE = [
# CorsMiddleware should be placed as high as possible and above WhiteNoiseMiddleware
# in particular
"corsheaders.middleware.CorsMiddleware",
# Ditto for securitymiddleware
"django.middleware.security.SecurityMiddleware",
"whitenoise.middleware.WhiteNoiseMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
"simple_history.middleware.HistoryRequestMiddleware",
]
# django-extensions is a set of developer friendly tools
if env("ENABLE_DJANGO_EXTENSIONS"):
INSTALLED_APPS.append("django_extensions")
ROOT_URLCONF = "hauki.urls"
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
],
},
},
]
WSGI_APPLICATION = "hauki.wsgi.application"
# Password validation
# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
"NAME": "django.contrib.auth.password_validation."
"UserAttributeSimilarityValidator",
},
{
"NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
},
{
"NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
},
{
"NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.0/topics/i18n/
# Map language codes to the (code, name) tuples used by Django
# We want to keep the ordering in LANGUAGES configuration variable,
# thus some gyrations
language_map = {x: y for x, y in GLOBAL_LANGUAGES}
try:
LANGUAGES = tuple((lang, language_map[lang]) for lang in env("LANGUAGES"))
except KeyError as e:
raise ImproperlyConfigured(f'unknown language code "{e.args[0]}"')
LANGUAGE_CODE = env("LANGUAGES")[0]
TIME_ZONE = "Europe/Helsinki"
USE_I18N = True
USE_L10N = True
USE_TZ = True
LOCALE_PATHS = [root("locale")]
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.0/howto/static-files/
STATIC_URL = env("STATIC_URL")
MEDIA_URL = env("MEDIA_URL")
STATIC_ROOT = env("STATIC_ROOT")
MEDIA_ROOT = env("MEDIA_ROOT")
# Whether to trust X-Forwarded-Host headers for all purposes
# where Django would need to make use of its own hostname
# fe. generating absolute URLs pointing to itself
# Most often used in reverse proxy setups
# https://docs.djangoproject.com/en/3.0/ref/settings/#use-x-forwarded-host
USE_X_FORWARDED_HOST = env("TRUST_X_FORWARDED_HOST")
# Specifies a header that is trusted to indicate that the request was using
# https while traversing over the Internet at large. This is used when
# a proxy terminates the TLS connection and forwards the request over
# a secure network. Specified using a tuple.
# https://docs.djangoproject.com/en/3.0/ref/settings/#secure-proxy-ssl-header
SECURE_PROXY_SSL_HEADER = env("SECURE_PROXY_SSL_HEADER")
CORS_ORIGIN_ALLOW_ALL = True
CSRF_COOKIE_NAME = "%s-csrftoken" % env("COOKIE_PREFIX")
SESSION_COOKIE_NAME = "%s-sessionid" % env("COOKIE_PREFIX")
# DRF Settings
# https://www.d
|
get_git_revision_hash
|
identifier_name
|
|
mod.rs
|
moves` closure which will be invoked with `(el, source,
/// handle, sibling)` whenever an element is clicked. If this closure returns
/// `false`, a drag event won't begin, and the event won't be prevented
/// either. The `handle` element will be the original click target, which
/// comes in handy to test if that element is an expected _"drag handle"_.
pub moves: Box<dyn FnMut(JsValue, JsValue, JsValue, JsValue) -> bool>,
/// You can set `accepts` to a closure with the following signature: `(el,
/// target, source, sibling)`. It'll be called to make sure that an element
/// `el`, that came from container `source`, can be dropped on container
/// `target` before a `sibling` element. The `sibling` can be `null`, which
/// would mean that the element would be placed as the last element in the
/// container. Note that if [`copy`](Options::copy) is set to `true`, `el` will be
/// set to the copy, instead of the originally dragged element.
pub accepts: Box<dyn FnMut(JsValue, JsValue, JsValue, JsValue) -> bool>,
/// You can provide an `invalid` closure with a `(el, handle)` signature.
/// This closure should return `true` for elements that shouldn't trigger a
/// drag. The `handle` argument is the element that was clicked, while `el`
/// is the item that would be dragged.
pub invalid: Box<dyn FnMut(JsValue, JsValue) -> bool>,
/// If `copy` is set to `true` _(or a closure that returns `true`)_, items
/// will be copied rather than moved. This implies the following differences:
///
/// Event | Move | Copy
/// ----------|------------------------------------------|---------------------------------------------
/// `drag` | Element will be concealed from `source` | Nothing happens
/// `drop` | Element will be moved into `target` | Element will be cloned into `target`
/// `remove` | Element will be removed from DOM | Nothing happens
/// `cancel` | Element will stay in `source` | Nothing happens
///
/// If a closure is passed, it'll be called whenever an element starts being
/// dragged in order to decide whether it should follow `copy` behavior or
/// not. This closure will be passed the element to be dragged as well as
/// its source container, in other words, the signature is `(el, handle)`.
///
/// `false` by default.
pub copy: CopyValue,
/// If [`copy`](Options::copy) is set to `true` _(or a closure that
/// returns `true`)_ and `copy_sort_source` is `true` as well, users will
/// be able to sort elements in `copy`-source containers.
///
/// `false` by default.
pub copy_sort_source: bool,
/// By default, spilling an element outside of any containers will move the
/// element back to the _drop position previewed by the feedback shadow_.
/// Setting `revert_on_spill` to `true` will ensure elements dropped outside
/// of any approved containers are moved back to the source element where
/// the drag event began, rather than stay at the _drop position previewed
/// by the feedback shadow_.
///
/// `false` by default.
pub revert_on_spill: bool,
/// By default, spilling an element outside of any containers will move the
/// element back to the _drop position previewed by the feedback shadow_.
/// Setting `remove_on_spill` to `true` will ensure elements dropped outside
/// of any approved containers are removed from the DOM. Note that `remove`
/// events won't fire if [`copy`](Options::copy) is set to `true`.
///
/// `false` by default.
pub remove_on_spill: bool,
/// When an element is dropped onto a container, it'll be placed near the
/// point where the mouse was released. If the `direction` is
/// [`Vertical`](Direction::Vertical),
/// the default value, the Y axis will be considered. Otherwise, if the
/// `direction` is [`Horizontal`](Direction::Horizontal),
/// the X axis will be considered.
///
/// [`Vertical`](Direction::Vertical), by default.
pub direction: Direction,
/// The DOM element where the mirror element displayed while dragging will
/// be appended to.
///
/// `document.body` by default.
pub mirror_container: JsValue,
/// When this option is enabled, if the user clicks on an input element the
/// drag won't start until their mouse pointer exits the input. This
/// translates into the user being able to select text in inputs contained
/// inside draggable elements, and still drag the element by moving their
/// mouse outside of the input -- so you get the best of both worlds.
///
/// `true` by default.
pub ignore_input_text_selection: bool,
/// The amount of horizontal movement (in pixels) for a click to be
/// considered a drag
///
/// `0` by default.
pub slide_factor_x: i32,
/// The amount of vertical movement (in pixels) for a click to be
/// considered a drag
///
/// `0` by default.
pub slide_factor_y: i32,
}
impl Default for Options {
fn default() -> Self {
Self {
is_container: Box::new(|_| false),
moves: Box::new(|_, _, _, _| true),
accepts: Box::new(|_, _, _, _| true),
invalid: Box::new(|_, _| false),
copy: CopyValue::Bool(false),
copy_sort_source: false,
revert_on_spill: false,
remove_on_spill: false,
direction: Direction::Vertical,
// Will default to document.body (avoiding web_sys dependency)
mirror_container: JsValue::UNDEFINED,
ignore_input_text_selection: true,
slide_factor_x: 0,
slide_factor_y: 0,
}
}
}
#[doc(hidden)]
#[wasm_bindgen]
pub struct OptionsImpl {
is_container_func: JsValue,
moves_func: JsValue,
accepts_func: JsValue,
invalid_func: JsValue,
copy_func_or_bool: JsValue,
#[wasm_bindgen(js_name = copySortSource)]
pub copy_sort_source: bool,
#[wasm_bindgen(js_name = revertOnSpill)]
pub revert_on_spill: bool,
#[wasm_bindgen(js_name = removeOnSpill)]
pub remove_on_spill: bool,
direction: String,
mirror_container_elem: JsValue,
#[wasm_bindgen(js_name = ignoreInputTextSelection)]
pub ignore_input_text_selection: bool,
#[wasm_bindgen(js_name = slideFactorX)]
pub slide_factor_x: i32,
#[wasm_bindgen(js_name = slideFactorY)]
pub slide_factor_y: i32,
}
impl From<Options> for OptionsImpl {
fn from(options: Options) -> Self {
OptionsImpl {
is_container_func: closure::to_js_1_ret(options.is_container),
moves_func: closure::to_js_4_ret(options.moves),
accepts_func: closure::to_js_4_ret(options.accepts),
invalid_func: closure::to_js_2_ret(options.invalid),
copy_func_or_bool: JsValue::from(options.copy),
mirror_container_elem: options.mirror_container,
copy_sort_source: options.copy_sort_source,
revert_on_spill: options.revert_on_spill,
remove_on_spill: options.remove_on_spill,
direction: options.direction.to_string(),
ignore_input_text_selection: options.ignore_input_text_selection,
slide_factor_x: options.slide_factor_x,
slide_factor_y: options.slide_factor_y,
}
}
}
impl Default for OptionsImpl {
fn default() -> Self {
OptionsImpl::from(Options::default())
}
}
#[wasm_bindgen]
#[doc(hidden)]
impl OptionsImpl {
#[wasm_bindgen(getter = isContainer)]
pub fn is_container_func(&self) -> JsValue {
self.is_container_func.clone()
}
#[wasm_bindgen(setter = isContainer)]
pub fn set_is_container_func(&mut self, val: JsValue) {
self.is_container_func = val;
}
#[wasm_bindgen(getter = moves)]
pub fn moves_func(&self) -> JsValue {
self.moves_func.clone()
}
#[wasm_bindgen(setter = moves)]
pub fn set_moves_func(&mut self, val: JsValue) {
self.moves_func = val;
}
#[wasm_bindgen(getter = accepts)]
pub fn accepts_func(&self) -> JsValue {
self.accepts_func.clone()
}
#[wasm_bindgen(setter = accepts)]
pub fn set_accepts_func(&mut self, val: JsValue) {
self.accepts_func = val;
}
#[wasm_bindgen(getter = invalid)]
pub fn invalid_func(&self) -> JsValue
|
{
self.invalid_func.clone()
}
|
identifier_body
|
|
mod.rs
|
: &str = "vertical";
const HORIZONTAL: &str = "horizontal";
match self {
Direction::Vertical => String::from(VERTICAL),
Direction::Horizontal => String::from(HORIZONTAL),
}
}
}
/// Used to pass options when activating Dragula
///
/// When passed to the [`dragula_options`](crate::dragula_options) function,
/// this struct can be used to specify options to control the behaviour of the
/// drag-and-drop functionality.
///
/// For example:
/// ```no_run
/// use dragula::*;
/// use dragula::options::CopyValue;
/// use web_sys::Element;
/// # use wasm_bindgen::JsValue;
///
/// # let element = JsValue::TRUE;
/// //--snip--
///
/// let options = Options {
/// invalid: Box::new(|el, _handle| {
/// Element::from(el).tag_name() == String::from("A")
/// }),
/// copy: CopyValue::Bool(true),
/// copy_sort_source: true,
/// remove_on_spill: true,
/// slide_factor_x: 10,
/// slide_factor_y: 10,
/// ..Options::default()
/// };
///
/// let drake = dragula_options(&[element], options);
///
/// //--snip--
/// ```
pub struct Options {
|
/// for this particular [`Drake`](crate::Drake) instance.
///
/// This closure will be invoked with the element that is being checked for
/// whether it is a container.
pub is_container: Box<dyn FnMut(JsValue) -> bool>,
/// You can define a `moves` closure which will be invoked with `(el, source,
/// handle, sibling)` whenever an element is clicked. If this closure returns
/// `false`, a drag event won't begin, and the event won't be prevented
/// either. The `handle` element will be the original click target, which
/// comes in handy to test if that element is an expected _"drag handle"_.
pub moves: Box<dyn FnMut(JsValue, JsValue, JsValue, JsValue) -> bool>,
/// You can set `accepts` to a closure with the following signature: `(el,
/// target, source, sibling)`. It'll be called to make sure that an element
/// `el`, that came from container `source`, can be dropped on container
/// `target` before a `sibling` element. The `sibling` can be `null`, which
/// would mean that the element would be placed as the last element in the
/// container. Note that if [`copy`](Options::copy) is set to `true`, `el` will be
/// set to the copy, instead of the originally dragged element.
pub accepts: Box<dyn FnMut(JsValue, JsValue, JsValue, JsValue) -> bool>,
/// You can provide an `invalid` closure with a `(el, handle)` signature.
/// This closure should return `true` for elements that shouldn't trigger a
/// drag. The `handle` argument is the element that was clicked, while `el`
/// is the item that would be dragged.
pub invalid: Box<dyn FnMut(JsValue, JsValue) -> bool>,
/// If `copy` is set to `true` _(or a closure that returns `true`)_, items
/// will be copied rather than moved. This implies the following differences:
///
/// Event | Move | Copy
/// ----------|------------------------------------------|---------------------------------------------
/// `drag` | Element will be concealed from `source` | Nothing happens
/// `drop` | Element will be moved into `target` | Element will be cloned into `target`
/// `remove` | Element will be removed from DOM | Nothing happens
/// `cancel` | Element will stay in `source` | Nothing happens
///
/// If a closure is passed, it'll be called whenever an element starts being
/// dragged in order to decide whether it should follow `copy` behavior or
/// not. This closure will be passed the element to be dragged as well as
/// its source container, in other words, the signature is `(el, handle)`.
///
/// `false` by default.
pub copy: CopyValue,
/// If [`copy`](Options::copy) is set to `true` _(or a closure that
/// returns `true`)_ and `copy_sort_source` is `true` as well, users will
/// be able to sort elements in `copy`-source containers.
///
/// `false` by default.
pub copy_sort_source: bool,
/// By default, spilling an element outside of any containers will move the
/// element back to the _drop position previewed by the feedback shadow_.
/// Setting `revert_on_spill` to `true` will ensure elements dropped outside
/// of any approved containers are moved back to the source element where
/// the drag event began, rather than stay at the _drop position previewed
/// by the feedback shadow_.
///
/// `false` by default.
pub revert_on_spill: bool,
/// By default, spilling an element outside of any containers will move the
/// element back to the _drop position previewed by the feedback shadow_.
/// Setting `remove_on_spill` to `true` will ensure elements dropped outside
/// of any approved containers are removed from the DOM. Note that `remove`
/// events won't fire if [`copy`](Options::copy) is set to `true`.
///
/// `false` by default.
pub remove_on_spill: bool,
/// When an element is dropped onto a container, it'll be placed near the
/// point where the mouse was released. If the `direction` is
/// [`Vertical`](Direction::Vertical),
/// the default value, the Y axis will be considered. Otherwise, if the
/// `direction` is [`Horizontal`](Direction::Horizontal),
/// the X axis will be considered.
///
/// [`Vertical`](Direction::Vertical), by default.
pub direction: Direction,
/// The DOM element where the mirror element displayed while dragging will
/// be appended to.
///
/// `document.body` by default.
pub mirror_container: JsValue,
/// When this option is enabled, if the user clicks on an input element the
/// drag won't start until their mouse pointer exits the input. This
/// translates into the user being able to select text in inputs contained
/// inside draggable elements, and still drag the element by moving their
/// mouse outside of the input -- so you get the best of both worlds.
///
/// `true` by default.
pub ignore_input_text_selection: bool,
/// The amount of horizontal movement (in pixels) for a click to be
/// considered a drag
///
/// `0` by default.
pub slide_factor_x: i32,
/// The amount of vertical movement (in pixels) for a click to be
/// considered a drag
///
/// `0` by default.
pub slide_factor_y: i32,
}
impl Default for Options {
fn default() -> Self {
Self {
is_container: Box::new(|_| false),
moves: Box::new(|_, _, _, _| true),
accepts: Box::new(|_, _, _, _| true),
invalid: Box::new(|_, _| false),
copy: CopyValue::Bool(false),
copy_sort_source: false,
revert_on_spill: false,
remove_on_spill: false,
direction: Direction::Vertical,
// Will default to document.body (avoiding web_sys dependency)
mirror_container: JsValue::UNDEFINED,
ignore_input_text_selection: true,
slide_factor_x: 0,
slide_factor_y: 0,
}
}
}
#[doc(hidden)]
#[wasm_bindgen]
pub struct OptionsImpl {
is_container_func: JsValue,
moves_func: JsValue,
accepts_func: JsValue,
invalid_func: JsValue,
copy_func_or_bool: JsValue,
#[wasm_bindgen(js_name = copySortSource)]
pub copy_sort_source: bool,
#[wasm_bindgen(js_name = revertOnSpill)]
pub revert_on_spill: bool,
#[wasm_bindgen(js_name = removeOnSpill)]
pub remove_on_spill: bool,
direction: String,
mirror_container_elem: JsValue,
#[wasm_bindgen(js_name = ignoreInputTextSelection)]
pub ignore_input_text_selection: bool,
#[wasm_bindgen(js_name = slideFactorX)]
pub slide_factor_x: i32,
#[wasm_bindgen(js_name = slideFactorY)]
pub slide_factor_y: i32,
}
impl From<Options> for OptionsImpl {
fn from(options: Options) -> Self {
OptionsImpl {
is_container_func: closure::to_js_1_ret(options.is_container),
moves_func: closure::to_js_4_ret(options.moves),
accepts_func: closure::to_js_4_ret(options.accepts),
invalid_func:
|
/// Besides the containers that you pass to [`dragula`](crate::dragula()),
/// or the containers you dynamically add, you can also use this closure to
/// specify any sort of logic that defines what is a container
|
random_line_split
|
mod.rs
|
;
/// use web_sys::Element;
/// # use wasm_bindgen::JsValue;
///
/// # let element = JsValue::TRUE;
/// //--snip--
///
/// let options = Options {
/// invalid: Box::new(|el, _handle| {
/// Element::from(el).tag_name() == String::from("A")
/// }),
/// copy: CopyValue::Bool(true),
/// copy_sort_source: true,
/// remove_on_spill: true,
/// slide_factor_x: 10,
/// slide_factor_y: 10,
/// ..Options::default()
/// };
///
/// let drake = dragula_options(&[element], options);
///
/// //--snip--
/// ```
pub struct Options {
/// Besides the containers that you pass to [`dragula`](crate::dragula()),
/// or the containers you dynamically add, you can also use this closure to
/// specify any sort of logic that defines what is a container
/// for this particular [`Drake`](crate::Drake) instance.
///
/// This closure will be invoked with the element that is being checked for
/// whether it is a container.
pub is_container: Box<dyn FnMut(JsValue) -> bool>,
/// You can define a `moves` closure which will be invoked with `(el, source,
/// handle, sibling)` whenever an element is clicked. If this closure returns
/// `false`, a drag event won't begin, and the event won't be prevented
/// either. The `handle` element will be the original click target, which
/// comes in handy to test if that element is an expected _"drag handle"_.
pub moves: Box<dyn FnMut(JsValue, JsValue, JsValue, JsValue) -> bool>,
/// You can set `accepts` to a closure with the following signature: `(el,
/// target, source, sibling)`. It'll be called to make sure that an element
/// `el`, that came from container `source`, can be dropped on container
/// `target` before a `sibling` element. The `sibling` can be `null`, which
/// would mean that the element would be placed as the last element in the
/// container. Note that if [`copy`](Options::copy) is set to `true`, `el` will be
/// set to the copy, instead of the originally dragged element.
pub accepts: Box<dyn FnMut(JsValue, JsValue, JsValue, JsValue) -> bool>,
/// You can provide an `invalid` closure with a `(el, handle)` signature.
/// This closure should return `true` for elements that shouldn't trigger a
/// drag. The `handle` argument is the element that was clicked, while `el`
/// is the item that would be dragged.
pub invalid: Box<dyn FnMut(JsValue, JsValue) -> bool>,
/// If `copy` is set to `true` _(or a closure that returns `true`)_, items
/// will be copied rather than moved. This implies the following differences:
///
/// Event | Move | Copy
/// ----------|------------------------------------------|---------------------------------------------
/// `drag` | Element will be concealed from `source` | Nothing happens
/// `drop` | Element will be moved into `target` | Element will be cloned into `target`
/// `remove` | Element will be removed from DOM | Nothing happens
/// `cancel` | Element will stay in `source` | Nothing happens
///
/// If a closure is passed, it'll be called whenever an element starts being
/// dragged in order to decide whether it should follow `copy` behavior or
/// not. This closure will be passed the element to be dragged as well as
/// its source container, in other words, the signature is `(el, handle)`.
///
/// `false` by default.
pub copy: CopyValue,
/// If [`copy`](Options::copy) is set to `true` _(or a closure that
/// returns `true`)_ and `copy_sort_source` is `true` as well, users will
/// be able to sort elements in `copy`-source containers.
///
/// `false` by default.
pub copy_sort_source: bool,
/// By default, spilling an element outside of any containers will move the
/// element back to the _drop position previewed by the feedback shadow_.
/// Setting `revert_on_spill` to `true` will ensure elements dropped outside
/// of any approved containers are moved back to the source element where
/// the drag event began, rather than stay at the _drop position previewed
/// by the feedback shadow_.
///
/// `false` by default.
pub revert_on_spill: bool,
/// By default, spilling an element outside of any containers will move the
/// element back to the _drop position previewed by the feedback shadow_.
/// Setting `remove_on_spill` to `true` will ensure elements dropped outside
/// of any approved containers are removed from the DOM. Note that `remove`
/// events won't fire if [`copy`](Options::copy) is set to `true`.
///
/// `false` by default.
pub remove_on_spill: bool,
/// When an element is dropped onto a container, it'll be placed near the
/// point where the mouse was released. If the `direction` is
/// [`Vertical`](Direction::Vertical),
/// the default value, the Y axis will be considered. Otherwise, if the
/// `direction` is [`Horizontal`](Direction::Horizontal),
/// the X axis will be considered.
///
/// [`Vertical`](Direction::Vertical), by default.
pub direction: Direction,
/// The DOM element where the mirror element displayed while dragging will
/// be appended to.
///
/// `document.body` by default.
pub mirror_container: JsValue,
/// When this option is enabled, if the user clicks on an input element the
/// drag won't start until their mouse pointer exits the input. This
/// translates into the user being able to select text in inputs contained
/// inside draggable elements, and still drag the element by moving their
/// mouse outside of the input -- so you get the best of both worlds.
///
/// `true` by default.
pub ignore_input_text_selection: bool,
/// The amount of horizontal movement (in pixels) for a click to be
/// considered a drag
///
/// `0` by default.
pub slide_factor_x: i32,
/// The amount of vertical movement (in pixels) for a click to be
/// considered a drag
///
/// `0` by default.
pub slide_factor_y: i32,
}
impl Default for Options {
fn default() -> Self {
Self {
is_container: Box::new(|_| false),
moves: Box::new(|_, _, _, _| true),
accepts: Box::new(|_, _, _, _| true),
invalid: Box::new(|_, _| false),
copy: CopyValue::Bool(false),
copy_sort_source: false,
revert_on_spill: false,
remove_on_spill: false,
direction: Direction::Vertical,
// Will default to document.body (avoiding web_sys dependency)
mirror_container: JsValue::UNDEFINED,
ignore_input_text_selection: true,
slide_factor_x: 0,
slide_factor_y: 0,
}
}
}
#[doc(hidden)]
#[wasm_bindgen]
pub struct OptionsImpl {
is_container_func: JsValue,
moves_func: JsValue,
accepts_func: JsValue,
invalid_func: JsValue,
copy_func_or_bool: JsValue,
#[wasm_bindgen(js_name = copySortSource)]
pub copy_sort_source: bool,
#[wasm_bindgen(js_name = revertOnSpill)]
pub revert_on_spill: bool,
#[wasm_bindgen(js_name = removeOnSpill)]
pub remove_on_spill: bool,
direction: String,
mirror_container_elem: JsValue,
#[wasm_bindgen(js_name = ignoreInputTextSelection)]
pub ignore_input_text_selection: bool,
#[wasm_bindgen(js_name = slideFactorX)]
pub slide_factor_x: i32,
#[wasm_bindgen(js_name = slideFactorY)]
pub slide_factor_y: i32,
}
impl From<Options> for OptionsImpl {
fn from(options: Options) -> Self {
OptionsImpl {
is_container_func: closure::to_js_1_ret(options.is_container),
moves_func: closure::to_js_4_ret(options.moves),
accepts_func: closure::to_js_4_ret(options.accepts),
invalid_func: closure::to_js_2_ret(options.invalid),
copy_func_or_bool: JsValue::from(options.copy),
mirror_container_elem: options.mirror_container,
copy_sort_source: options.copy_sort_source,
revert_on_spill: options.revert_on_spill,
remove_on_spill: options.remove_on_spill,
direction: options.direction.to_string(),
ignore_input_text_selection: options.ignore_input_text_selection,
slide_factor_x: options.slide_factor_x,
slide_factor_y: options.slide_factor_y,
}
}
}
impl Default for OptionsImpl {
fn
|
default
|
identifier_name
|
|
train.py
|
": [neighbor_features],
"features": [NODE_FEATURES],
"combined": [neighbor_features, NODE_FEATURES],
}
return dict(y for x in all_features[feat_type] for y in x.items())
class
|
:
def __init__(self, products_path, dataset_path, conf, logger, data_logger=None):
self.conf = conf
self._logger = logger
self._data_logger = EmptyLogger() if data_logger is None else data_logger
self.products_path = products_path
self.loader = GraphLoader(dataset_path, is_max_connected=False, norm_adj=conf["norm_adj"],
cuda_num=conf["cuda"], logger=self._logger)
self._criterion = torch.nn.NLLLoss()
def _get_models(self):
bow_feat = self.loader.bow_mx
topo_feat = self.loader.topo_mx
model1 = GCN(nfeat=bow_feat.shape[1],
hlayers=[self.conf["kipf"]["hidden"]],
nclass=self.loader.num_labels,
dropout=self.conf["kipf"]["dropout"])
opt1 = optim.Adam(model1.parameters(), lr=self.conf["kipf"]["lr"],
weight_decay=self.conf["kipf"]["weight_decay"])
model2 = GCNCombined(nbow=bow_feat.shape[1],
nfeat=topo_feat.shape[1],
hlayers=self.conf["hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"])
opt2 = optim.Adam(model2.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
model3 = GCN(nfeat=topo_feat.shape[1],
hlayers=self.conf["multi_hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"],
layer_type=None)
opt3 = optim.Adam(model3.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
model4 = GCN(nfeat=topo_feat.shape[1],
hlayers=self.conf["multi_hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"],
layer_type=AsymmetricGCN)
opt4 = optim.Adam(model4.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
return {
"kipf": {
"model": model1, "optimizer": opt1,
"arguments": [self.loader.bow_mx, self.loader.adj_mx],
"labels": self.loader.labels,
},
"our_combined": {
"model": model2, "optimizer": opt2,
"arguments": [self.loader.bow_mx, self.loader.topo_mx, self.loader.adj_rt_mx],
"labels": self.loader.labels,
},
"topo_sym": {
"model": model3, "optimizer": opt3,
"arguments": [self.loader.topo_mx, self.loader.adj_mx],
"labels": self.loader.labels,
},
"topo_asym": {
"model": model4, "optimizer": opt4,
"arguments": [self.loader.topo_mx, self.loader.adj_rt_mx],
"labels": self.loader.labels,
},
}
def run(self, train_p, feat_type):
features_meta = get_features(feat_type, is_directed=self.loader.is_graph_directed)
self.loader.split_train(train_p, features_meta)
models = self._get_models()
if self.conf["cuda"] is not None:
[model["model"].cuda(self.conf["cuda"]) for model in models.values()]
for model in models.values():
model["arguments"] = list(map(Variable, model["arguments"]))
model["labels"] = Variable(model["labels"])
# Train model
meters = {name: model_meter.ModelMeter(self.loader.distinct_labels) for name in models}
train_idx, val_idx = self.loader.train_idx, self.loader.val_idx
for epoch in range(self.conf["epochs"]):
for name, model_args in models.items():
self._train(epoch, name, model_args, train_idx, val_idx, meters[name])
# Testing
test_idx = self.loader.test_idx
for name, model_args in models.items():
meter = meters[name]
self._test(name, model_args, test_idx, meter)
self._data_logger.log_info(
model_name=name,
loss=meter.last_val("loss_test"),
acc=meter.last_val("acc_test"),
train_p=(train_p / (2 - train_p)) * 100,
norm_adj=self.conf["norm_adj"],
feat_type=self.conf["feat_type"]
)
# Currently supporting only binary class plotting
# meters[name].plot_auc(should_show=False)
# import matplotlib.pyplot as plt
# plt.savefig(os.path.join(self.products_path, time.strftime("%H_%M_%S_" + name)))
return meters
def _train(self, epoch, model_name, model_args, idx_train, idx_val, meter):
model, optimizer = model_args["model"], model_args["optimizer"]
arguments, labels = model_args["arguments"], model_args["labels"]
model.train()
optimizer.zero_grad()
output = model(*arguments)
loss_train = self._criterion(output[idx_train], labels[idx_train])
acc_train = model_meter.accuracy(output[idx_train], labels[idx_train])
meter.update_vals(loss_train=loss_train.item(), acc_train=acc_train)
loss_train.backward()
optimizer.step()
if not self.conf["fastmode"]:
# Evaluate validation set performance separately,
# deactivates dropout during validation run.
model.eval()
output = model(*arguments)
loss_val = self._criterion(output[idx_val], labels[idx_val])
acc_val = model_meter.accuracy(output[idx_val], labels[idx_val])
meter.update_vals(loss_val=loss_val.item(), acc_val=acc_val)
self._logger.debug("%s: Epoch: %03d, %s", model_name, epoch + 1, meter.log_str())
def _test(self, model_name, model_args, test_idx, meter):
model, arguments, labels = model_args["model"], model_args["arguments"], model_args["labels"]
model.eval()
output = model(*arguments)
loss_test = functional.nll_loss(output[test_idx], labels[test_idx])
acc_test = model_meter.accuracy(output[test_idx], labels[test_idx])
meter.update_diff(output[test_idx], labels[test_idx])
meter.update_vals(loss_test=loss_test.item(), acc_test=acc_test)
self._logger.info("%s: Test, %s", model_name, meter.log_str(log_vals=["loss_test", "acc_test"]))
# self._logger.info("%s Test: loss= %.4f accuracy= %.4f" % (model_name, loss_test.item(), acc_test.item()))
# return {"loss": loss_test.item(), "acc": acc_test.item()}
def init_seed(seed, cuda=None):
np.random.seed(seed)
torch.manual_seed(seed)
if cuda is not None:
torch.cuda.manual_seed(seed)
def aggregate_results(res_list, logger):
aggregated = {}
for cur_res in res_list:
for name, vals in cur_res.items():
if name not in aggregated:
aggregated[name] = {}
for key, val in vals.items():
if key not in aggregated[name]:
aggregated[name][key] = []
aggregated[name][key].append(val)
for name, vals in aggregated.items():
val_list = sorted(vals.items(), key=lambda x: x[0], reverse=True)
logger.info("*" * 15 + "%s mean: %s", name,
", ".join("%s=%3.4f" % (key, np.mean(val)) for key, val in val_list))
logger.info("*" * 15 + "%s std: %s", name, ", ".join("%s=%3.4f" % (key, np.std(val)) for key, val in val_list))
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--cuda', type=int, default=1,
help='Specify cuda device number')
parser.add_argument('--fastmode', action='store_true', default=False,
help='Validate during training pass.')
parser.add_argument('--seed', type=int, default=0, help='Random seed.')
parser.add_argument('--epochs', type=int, default=200,
help='Number of epochs to train.')
parser.add_argument('--dataset', type=str, default="cora",
help='The dataset to use.')
# parser.add_argument('--prefix', type=str, default="",
# help='The prefix of the products dir name.')
args = parser.parse_args()
# args.cuda = not args.no_cuda and torch.cuda.is_available()
if not torch.cuda.is_available():
args.cuda = None
return args
def main():
args = parse_args()
dataset = "cora" # args.dataset
seed = random.randint(1, 1000000000)
conf = {
"kipf": {"hidden": 16, "dropout": 0.5, "lr": 0.01, "weight_decay": 5e-4},
"hidden_layers": [16], "multi_hidden_layers": [100, 20], "dropout": 0.6, "lr": 0.01, "weight_decay": 0.001,
"dataset": dataset, "epochs": args.epochs, "cuda": args
|
ModelRunner
|
identifier_name
|
train.py
|
": [neighbor_features],
"features": [NODE_FEATURES],
"combined": [neighbor_features, NODE_FEATURES],
}
return dict(y for x in all_features[feat_type] for y in x.items())
class ModelRunner:
def __init__(self, products_path, dataset_path, conf, logger, data_logger=None):
self.conf = conf
self._logger = logger
self._data_logger = EmptyLogger() if data_logger is None else data_logger
self.products_path = products_path
self.loader = GraphLoader(dataset_path, is_max_connected=False, norm_adj=conf["norm_adj"],
cuda_num=conf["cuda"], logger=self._logger)
self._criterion = torch.nn.NLLLoss()
def _get_models(self):
bow_feat = self.loader.bow_mx
topo_feat = self.loader.topo_mx
model1 = GCN(nfeat=bow_feat.shape[1],
hlayers=[self.conf["kipf"]["hidden"]],
nclass=self.loader.num_labels,
dropout=self.conf["kipf"]["dropout"])
opt1 = optim.Adam(model1.parameters(), lr=self.conf["kipf"]["lr"],
weight_decay=self.conf["kipf"]["weight_decay"])
model2 = GCNCombined(nbow=bow_feat.shape[1],
nfeat=topo_feat.shape[1],
hlayers=self.conf["hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"])
opt2 = optim.Adam(model2.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
model3 = GCN(nfeat=topo_feat.shape[1],
hlayers=self.conf["multi_hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"],
layer_type=None)
opt3 = optim.Adam(model3.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
model4 = GCN(nfeat=topo_feat.shape[1],
hlayers=self.conf["multi_hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"],
layer_type=AsymmetricGCN)
opt4 = optim.Adam(model4.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
return {
"kipf": {
"model": model1, "optimizer": opt1,
"arguments": [self.loader.bow_mx, self.loader.adj_mx],
"labels": self.loader.labels,
},
"our_combined": {
"model": model2, "optimizer": opt2,
"arguments": [self.loader.bow_mx, self.loader.topo_mx, self.loader.adj_rt_mx],
"labels": self.loader.labels,
},
"topo_sym": {
"model": model3, "optimizer": opt3,
"arguments": [self.loader.topo_mx, self.loader.adj_mx],
"labels": self.loader.labels,
},
"topo_asym": {
"model": model4, "optimizer": opt4,
"arguments": [self.loader.topo_mx, self.loader.adj_rt_mx],
"labels": self.loader.labels,
},
}
def run(self, train_p, feat_type):
features_meta = get_features(feat_type, is_directed=self.loader.is_graph_directed)
self.loader.split_train(train_p, features_meta)
models = self._get_models()
if self.conf["cuda"] is not None:
[model["model"].cuda(self.conf["cuda"]) for model in models.values()]
for model in models.values():
model["arguments"] = list(map(Variable, model["arguments"]))
model["labels"] = Variable(model["labels"])
# Train model
meters = {name: model_meter.ModelMeter(self.loader.distinct_labels) for name in models}
train_idx, val_idx = self.loader.train_idx, self.loader.val_idx
for epoch in range(self.conf["epochs"]):
for name, model_args in models.items():
self._train(epoch, name, model_args, train_idx, val_idx, meters[name])
# Testing
test_idx = self.loader.test_idx
for name, model_args in models.items():
meter = meters[name]
self._test(name, model_args, test_idx, meter)
self._data_logger.log_info(
model_name=name,
loss=meter.last_val("loss_test"),
acc=meter.last_val("acc_test"),
train_p=(train_p / (2 - train_p)) * 100,
norm_adj=self.conf["norm_adj"],
feat_type=self.conf["feat_type"]
)
# Currently supporting only binary class plotting
# meters[name].plot_auc(should_show=False)
# import matplotlib.pyplot as plt
# plt.savefig(os.path.join(self.products_path, time.strftime("%H_%M_%S_" + name)))
return meters
def _train(self, epoch, model_name, model_args, idx_train, idx_val, meter):
model, optimizer = model_args["model"], model_args["optimizer"]
arguments, labels = model_args["arguments"], model_args["labels"]
model.train()
optimizer.zero_grad()
output = model(*arguments)
loss_train = self._criterion(output[idx_train], labels[idx_train])
acc_train = model_meter.accuracy(output[idx_train], labels[idx_train])
meter.update_vals(loss_train=loss_train.item(), acc_train=acc_train)
loss_train.backward()
optimizer.step()
if not self.conf["fastmode"]:
# Evaluate validation set performance separately,
# deactivates dropout during validation run.
model.eval()
output = model(*arguments)
loss_val = self._criterion(output[idx_val], labels[idx_val])
acc_val = model_meter.accuracy(output[idx_val], labels[idx_val])
meter.update_vals(loss_val=loss_val.item(), acc_val=acc_val)
self._logger.debug("%s: Epoch: %03d, %s", model_name, epoch + 1, meter.log_str())
def _test(self, model_name, model_args, test_idx, meter):
model, arguments, labels = model_args["model"], model_args["arguments"], model_args["labels"]
model.eval()
output = model(*arguments)
loss_test = functional.nll_loss(output[test_idx], labels[test_idx])
acc_test = model_meter.accuracy(output[test_idx], labels[test_idx])
meter.update_diff(output[test_idx], labels[test_idx])
meter.update_vals(loss_test=loss_test.item(), acc_test=acc_test)
self._logger.info("%s: Test, %s", model_name, meter.log_str(log_vals=["loss_test", "acc_test"]))
# self._logger.info("%s Test: loss= %.4f accuracy= %.4f" % (model_name, loss_test.item(), acc_test.item()))
# return {"loss": loss_test.item(), "acc": acc_test.item()}
def init_seed(seed, cuda=None):
np.random.seed(seed)
torch.manual_seed(seed)
if cuda is not None:
torch.cuda.manual_seed(seed)
def aggregate_results(res_list, logger):
aggregated = {}
for cur_res in res_list:
for name, vals in cur_res.items():
if name not in aggregated:
aggregated[name] = {}
for key, val in vals.items():
if key not in aggregated[name]:
aggregated[name][key] = []
aggregated[name][key].append(val)
for name, vals in aggregated.items():
|
val_list = sorted(vals.items(), key=lambda x: x[0], reverse=True)
logger.info("*" * 15 + "%s mean: %s", name,
", ".join("%s=%3.4f" % (key, np.mean(val)) for key, val in val_list))
logger.info("*" * 15 + "%s std: %s", name, ", ".join("%s=%3.4f" % (key, np.std(val)) for key, val in val_list))
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--cuda', type=int, default=1,
help='Specify cuda device number')
parser.add_argument('--fastmode', action='store_true', default=False,
help='Validate during training pass.')
parser.add_argument('--seed', type=int, default=0, help='Random seed.')
parser.add_argument('--epochs', type=int, default=200,
help='Number of epochs to train.')
parser.add_argument('--dataset', type=str, default="cora",
help='The dataset to use.')
# parser.add_argument('--prefix', type=str, default="",
# help='The prefix of the products dir name.')
args = parser.parse_args()
# args.cuda = not args.no_cuda and torch.cuda.is_available()
if not torch.cuda.is_available():
args.cuda = None
return args
def main():
args = parse_args()
dataset = "cora" # args.dataset
seed = random.randint(1, 1000000000)
conf = {
"kipf": {"hidden": 16, "dropout": 0.5, "lr": 0.01, "weight_decay": 5e-4},
"hidden_layers": [16], "multi_hidden_layers": [100, 20], "dropout": 0.6, "lr": 0.01, "weight_decay": 0.001,
"dataset": dataset, "epochs": args.epochs, "cuda": args.cuda
|
random_line_split
|
|
train.py
|
": [neighbor_features],
"features": [NODE_FEATURES],
"combined": [neighbor_features, NODE_FEATURES],
}
return dict(y for x in all_features[feat_type] for y in x.items())
class ModelRunner:
def __init__(self, products_path, dataset_path, conf, logger, data_logger=None):
self.conf = conf
self._logger = logger
self._data_logger = EmptyLogger() if data_logger is None else data_logger
self.products_path = products_path
self.loader = GraphLoader(dataset_path, is_max_connected=False, norm_adj=conf["norm_adj"],
cuda_num=conf["cuda"], logger=self._logger)
self._criterion = torch.nn.NLLLoss()
def _get_models(self):
bow_feat = self.loader.bow_mx
topo_feat = self.loader.topo_mx
model1 = GCN(nfeat=bow_feat.shape[1],
hlayers=[self.conf["kipf"]["hidden"]],
nclass=self.loader.num_labels,
dropout=self.conf["kipf"]["dropout"])
opt1 = optim.Adam(model1.parameters(), lr=self.conf["kipf"]["lr"],
weight_decay=self.conf["kipf"]["weight_decay"])
model2 = GCNCombined(nbow=bow_feat.shape[1],
nfeat=topo_feat.shape[1],
hlayers=self.conf["hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"])
opt2 = optim.Adam(model2.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
model3 = GCN(nfeat=topo_feat.shape[1],
hlayers=self.conf["multi_hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"],
layer_type=None)
opt3 = optim.Adam(model3.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
model4 = GCN(nfeat=topo_feat.shape[1],
hlayers=self.conf["multi_hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"],
layer_type=AsymmetricGCN)
opt4 = optim.Adam(model4.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
return {
"kipf": {
"model": model1, "optimizer": opt1,
"arguments": [self.loader.bow_mx, self.loader.adj_mx],
"labels": self.loader.labels,
},
"our_combined": {
"model": model2, "optimizer": opt2,
"arguments": [self.loader.bow_mx, self.loader.topo_mx, self.loader.adj_rt_mx],
"labels": self.loader.labels,
},
"topo_sym": {
"model": model3, "optimizer": opt3,
"arguments": [self.loader.topo_mx, self.loader.adj_mx],
"labels": self.loader.labels,
},
"topo_asym": {
"model": model4, "optimizer": opt4,
"arguments": [self.loader.topo_mx, self.loader.adj_rt_mx],
"labels": self.loader.labels,
},
}
def run(self, train_p, feat_type):
features_meta = get_features(feat_type, is_directed=self.loader.is_graph_directed)
self.loader.split_train(train_p, features_meta)
models = self._get_models()
if self.conf["cuda"] is not None:
[model["model"].cuda(self.conf["cuda"]) for model in models.values()]
for model in models.values():
model["arguments"] = list(map(Variable, model["arguments"]))
model["labels"] = Variable(model["labels"])
# Train model
meters = {name: model_meter.ModelMeter(self.loader.distinct_labels) for name in models}
train_idx, val_idx = self.loader.train_idx, self.loader.val_idx
for epoch in range(self.conf["epochs"]):
for name, model_args in models.items():
|
# Testing
test_idx = self.loader.test_idx
for name, model_args in models.items():
meter = meters[name]
self._test(name, model_args, test_idx, meter)
self._data_logger.log_info(
model_name=name,
loss=meter.last_val("loss_test"),
acc=meter.last_val("acc_test"),
train_p=(train_p / (2 - train_p)) * 100,
norm_adj=self.conf["norm_adj"],
feat_type=self.conf["feat_type"]
)
# Currently supporting only binary class plotting
# meters[name].plot_auc(should_show=False)
# import matplotlib.pyplot as plt
# plt.savefig(os.path.join(self.products_path, time.strftime("%H_%M_%S_" + name)))
return meters
def _train(self, epoch, model_name, model_args, idx_train, idx_val, meter):
model, optimizer = model_args["model"], model_args["optimizer"]
arguments, labels = model_args["arguments"], model_args["labels"]
model.train()
optimizer.zero_grad()
output = model(*arguments)
loss_train = self._criterion(output[idx_train], labels[idx_train])
acc_train = model_meter.accuracy(output[idx_train], labels[idx_train])
meter.update_vals(loss_train=loss_train.item(), acc_train=acc_train)
loss_train.backward()
optimizer.step()
if not self.conf["fastmode"]:
# Evaluate validation set performance separately,
# deactivates dropout during validation run.
model.eval()
output = model(*arguments)
loss_val = self._criterion(output[idx_val], labels[idx_val])
acc_val = model_meter.accuracy(output[idx_val], labels[idx_val])
meter.update_vals(loss_val=loss_val.item(), acc_val=acc_val)
self._logger.debug("%s: Epoch: %03d, %s", model_name, epoch + 1, meter.log_str())
def _test(self, model_name, model_args, test_idx, meter):
model, arguments, labels = model_args["model"], model_args["arguments"], model_args["labels"]
model.eval()
output = model(*arguments)
loss_test = functional.nll_loss(output[test_idx], labels[test_idx])
acc_test = model_meter.accuracy(output[test_idx], labels[test_idx])
meter.update_diff(output[test_idx], labels[test_idx])
meter.update_vals(loss_test=loss_test.item(), acc_test=acc_test)
self._logger.info("%s: Test, %s", model_name, meter.log_str(log_vals=["loss_test", "acc_test"]))
# self._logger.info("%s Test: loss= %.4f accuracy= %.4f" % (model_name, loss_test.item(), acc_test.item()))
# return {"loss": loss_test.item(), "acc": acc_test.item()}
def init_seed(seed, cuda=None):
np.random.seed(seed)
torch.manual_seed(seed)
if cuda is not None:
torch.cuda.manual_seed(seed)
def aggregate_results(res_list, logger):
aggregated = {}
for cur_res in res_list:
for name, vals in cur_res.items():
if name not in aggregated:
aggregated[name] = {}
for key, val in vals.items():
if key not in aggregated[name]:
aggregated[name][key] = []
aggregated[name][key].append(val)
for name, vals in aggregated.items():
val_list = sorted(vals.items(), key=lambda x: x[0], reverse=True)
logger.info("*" * 15 + "%s mean: %s", name,
", ".join("%s=%3.4f" % (key, np.mean(val)) for key, val in val_list))
logger.info("*" * 15 + "%s std: %s", name, ", ".join("%s=%3.4f" % (key, np.std(val)) for key, val in val_list))
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--cuda', type=int, default=1,
help='Specify cuda device number')
parser.add_argument('--fastmode', action='store_true', default=False,
help='Validate during training pass.')
parser.add_argument('--seed', type=int, default=0, help='Random seed.')
parser.add_argument('--epochs', type=int, default=200,
help='Number of epochs to train.')
parser.add_argument('--dataset', type=str, default="cora",
help='The dataset to use.')
# parser.add_argument('--prefix', type=str, default="",
# help='The prefix of the products dir name.')
args = parser.parse_args()
# args.cuda = not args.no_cuda and torch.cuda.is_available()
if not torch.cuda.is_available():
args.cuda = None
return args
def main():
args = parse_args()
dataset = "cora" # args.dataset
seed = random.randint(1, 1000000000)
conf = {
"kipf": {"hidden": 16, "dropout": 0.5, "lr": 0.01, "weight_decay": 5e-4},
"hidden_layers": [16], "multi_hidden_layers": [100, 20], "dropout": 0.6, "lr": 0.01, "weight_decay": 0.001,
"dataset": dataset, "epochs": args.epochs, "cuda": args
|
self._train(epoch, name, model_args, train_idx, val_idx, meters[name])
|
conditional_block
|
train.py
|
": [neighbor_features],
"features": [NODE_FEATURES],
"combined": [neighbor_features, NODE_FEATURES],
}
return dict(y for x in all_features[feat_type] for y in x.items())
class ModelRunner:
def __init__(self, products_path, dataset_path, conf, logger, data_logger=None):
self.conf = conf
self._logger = logger
self._data_logger = EmptyLogger() if data_logger is None else data_logger
self.products_path = products_path
self.loader = GraphLoader(dataset_path, is_max_connected=False, norm_adj=conf["norm_adj"],
cuda_num=conf["cuda"], logger=self._logger)
self._criterion = torch.nn.NLLLoss()
def _get_models(self):
|
dropout=self.conf["dropout"],
layer_type=None)
opt3 = optim.Adam(model3.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
model4 = GCN(nfeat=topo_feat.shape[1],
hlayers=self.conf["multi_hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"],
layer_type=AsymmetricGCN)
opt4 = optim.Adam(model4.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
return {
"kipf": {
"model": model1, "optimizer": opt1,
"arguments": [self.loader.bow_mx, self.loader.adj_mx],
"labels": self.loader.labels,
},
"our_combined": {
"model": model2, "optimizer": opt2,
"arguments": [self.loader.bow_mx, self.loader.topo_mx, self.loader.adj_rt_mx],
"labels": self.loader.labels,
},
"topo_sym": {
"model": model3, "optimizer": opt3,
"arguments": [self.loader.topo_mx, self.loader.adj_mx],
"labels": self.loader.labels,
},
"topo_asym": {
"model": model4, "optimizer": opt4,
"arguments": [self.loader.topo_mx, self.loader.adj_rt_mx],
"labels": self.loader.labels,
},
}
def run(self, train_p, feat_type):
features_meta = get_features(feat_type, is_directed=self.loader.is_graph_directed)
self.loader.split_train(train_p, features_meta)
models = self._get_models()
if self.conf["cuda"] is not None:
[model["model"].cuda(self.conf["cuda"]) for model in models.values()]
for model in models.values():
model["arguments"] = list(map(Variable, model["arguments"]))
model["labels"] = Variable(model["labels"])
# Train model
meters = {name: model_meter.ModelMeter(self.loader.distinct_labels) for name in models}
train_idx, val_idx = self.loader.train_idx, self.loader.val_idx
for epoch in range(self.conf["epochs"]):
for name, model_args in models.items():
self._train(epoch, name, model_args, train_idx, val_idx, meters[name])
# Testing
test_idx = self.loader.test_idx
for name, model_args in models.items():
meter = meters[name]
self._test(name, model_args, test_idx, meter)
self._data_logger.log_info(
model_name=name,
loss=meter.last_val("loss_test"),
acc=meter.last_val("acc_test"),
train_p=(train_p / (2 - train_p)) * 100,
norm_adj=self.conf["norm_adj"],
feat_type=self.conf["feat_type"]
)
# Currently supporting only binary class plotting
# meters[name].plot_auc(should_show=False)
# import matplotlib.pyplot as plt
# plt.savefig(os.path.join(self.products_path, time.strftime("%H_%M_%S_" + name)))
return meters
def _train(self, epoch, model_name, model_args, idx_train, idx_val, meter):
model, optimizer = model_args["model"], model_args["optimizer"]
arguments, labels = model_args["arguments"], model_args["labels"]
model.train()
optimizer.zero_grad()
output = model(*arguments)
loss_train = self._criterion(output[idx_train], labels[idx_train])
acc_train = model_meter.accuracy(output[idx_train], labels[idx_train])
meter.update_vals(loss_train=loss_train.item(), acc_train=acc_train)
loss_train.backward()
optimizer.step()
if not self.conf["fastmode"]:
# Evaluate validation set performance separately,
# deactivates dropout during validation run.
model.eval()
output = model(*arguments)
loss_val = self._criterion(output[idx_val], labels[idx_val])
acc_val = model_meter.accuracy(output[idx_val], labels[idx_val])
meter.update_vals(loss_val=loss_val.item(), acc_val=acc_val)
self._logger.debug("%s: Epoch: %03d, %s", model_name, epoch + 1, meter.log_str())
def _test(self, model_name, model_args, test_idx, meter):
model, arguments, labels = model_args["model"], model_args["arguments"], model_args["labels"]
model.eval()
output = model(*arguments)
loss_test = functional.nll_loss(output[test_idx], labels[test_idx])
acc_test = model_meter.accuracy(output[test_idx], labels[test_idx])
meter.update_diff(output[test_idx], labels[test_idx])
meter.update_vals(loss_test=loss_test.item(), acc_test=acc_test)
self._logger.info("%s: Test, %s", model_name, meter.log_str(log_vals=["loss_test", "acc_test"]))
# self._logger.info("%s Test: loss= %.4f accuracy= %.4f" % (model_name, loss_test.item(), acc_test.item()))
# return {"loss": loss_test.item(), "acc": acc_test.item()}
def init_seed(seed, cuda=None):
np.random.seed(seed)
torch.manual_seed(seed)
if cuda is not None:
torch.cuda.manual_seed(seed)
def aggregate_results(res_list, logger):
aggregated = {}
for cur_res in res_list:
for name, vals in cur_res.items():
if name not in aggregated:
aggregated[name] = {}
for key, val in vals.items():
if key not in aggregated[name]:
aggregated[name][key] = []
aggregated[name][key].append(val)
for name, vals in aggregated.items():
val_list = sorted(vals.items(), key=lambda x: x[0], reverse=True)
logger.info("*" * 15 + "%s mean: %s", name,
", ".join("%s=%3.4f" % (key, np.mean(val)) for key, val in val_list))
logger.info("*" * 15 + "%s std: %s", name, ", ".join("%s=%3.4f" % (key, np.std(val)) for key, val in val_list))
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--cuda', type=int, default=1,
help='Specify cuda device number')
parser.add_argument('--fastmode', action='store_true', default=False,
help='Validate during training pass.')
parser.add_argument('--seed', type=int, default=0, help='Random seed.')
parser.add_argument('--epochs', type=int, default=200,
help='Number of epochs to train.')
parser.add_argument('--dataset', type=str, default="cora",
help='The dataset to use.')
# parser.add_argument('--prefix', type=str, default="",
# help='The prefix of the products dir name.')
args = parser.parse_args()
# args.cuda = not args.no_cuda and torch.cuda.is_available()
if not torch.cuda.is_available():
args.cuda = None
return args
def main():
args = parse_args()
dataset = "cora" # args.dataset
seed = random.randint(1, 1000000000)
conf = {
"kipf": {"hidden": 16, "dropout": 0.5, "lr": 0.01, "weight_decay": 5e-4},
"hidden_layers": [16], "multi_hidden_layers": [100, 20], "dropout": 0.6, "lr": 0.01, "weight_decay": 0.001,
"dataset": dataset, "epochs": args.epochs, "cuda": args.cuda
|
bow_feat = self.loader.bow_mx
topo_feat = self.loader.topo_mx
model1 = GCN(nfeat=bow_feat.shape[1],
hlayers=[self.conf["kipf"]["hidden"]],
nclass=self.loader.num_labels,
dropout=self.conf["kipf"]["dropout"])
opt1 = optim.Adam(model1.parameters(), lr=self.conf["kipf"]["lr"],
weight_decay=self.conf["kipf"]["weight_decay"])
model2 = GCNCombined(nbow=bow_feat.shape[1],
nfeat=topo_feat.shape[1],
hlayers=self.conf["hidden_layers"],
nclass=self.loader.num_labels,
dropout=self.conf["dropout"])
opt2 = optim.Adam(model2.parameters(), lr=self.conf["lr"], weight_decay=self.conf["weight_decay"])
model3 = GCN(nfeat=topo_feat.shape[1],
hlayers=self.conf["multi_hidden_layers"],
nclass=self.loader.num_labels,
|
identifier_body
|
CAAPR_Pipeline.py
|
_async( CAAPR.CAAPR_Photom.SubpipelinePhotom, args=(source_dict, bands_dict[band], kwargs_dict) ) )
pool.close()
pool.join()
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Gathering parallel threads.'
photom_output_list = [output.get() for output in photom_output_list if output.successful()==True]
photom_list = [photom for photom in photom_output_list if photom!=None]
# If parallelisation is disabled, process sources one-at-a-time
elif kwargs_dict['parallel']==False:
for band in bands_dict.keys():
photom_output_list.append( CAAPR.CAAPR_Photom.SubpipelinePhotom(source_dict, bands_dict[band], kwargs_dict) )
photom_list = [photom for photom in photom_output_list if photom!=None]
# Shortcut if no photometry is done
if not kwargs_dict['do_photom']:
photom_attempts = 'Complete'
gc.collect()
return
# Check that all photometry completed
photom_attempts, photom_output_list = CAAPR.CAAPR_Photom.PhotomCheck(photom_attempts, photom_output_list, source_dict, bands_dict, kwargs_dict)
# Record photometry results to file
CAAPR.CAAPR_IO.RecordPhotom(photom_list, source_dict, bands_dict, kwargs_dict)
# Prepare thumbnail images for bands excluded from photometry
CAAPR.CAAPR_Photom.ExcludedThumb(source_dict, bands_dict, kwargs_dict)
# Create grid of thumbnail images
CAAPR.CAAPR_IO.PhotomThumbGrid(source_dict, bands_dict, kwargs_dict)
# Report time taken to do photometry, and tidy up
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Time taken performing actual photometry: '+str(ChrisFuncs.FromGitHub.randlet.ToPrecision(time.time()-photom_start,4))+' seconds.'
# Tidy up temporary files and paths
bands_dict = PathTidy(source_dict, bands_dict, kwargs_dict)
# Report time taken for source, and tidy up garbage
gc.collect()
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Total time taken for souce: '+str(ChrisFuncs.FromGitHub.randlet.ToPrecision(time.time()-source_start,4))+' seconds.'
if kwargs_dict['thumbnails']==True and kwargs_dict['messy']==False:
[os.remove(os.path.join(kwargs_dict['temp_dir_path'],'Processed_Maps',processed_map)) for processed_map in os.listdir(os.path.join(kwargs_dict['temp_dir_path'],'Processed_Maps')) if '.fits' in processed_map]
# Define function to check if data actually exists for any band for this source
def SourcePrelim(source_dict, bands_dict, kwargs_dict):
# Check that any of the bands actually have data for this source
kwargs_dict_copy = copy.deepcopy(kwargs_dict)
kwargs_dict_copy['verbose'] = False
bands_check = []
for band in bands_dict.keys():
source_id = source_dict['name']+'_'+bands_dict[band]['band_name']
in_fitspath, file_found = CAAPR.CAAPR_Pipeline.FilePrelim(source_dict, bands_dict[band], kwargs_dict_copy)
bands_check.append(file_found)
# Report to user if no data found
if True not in bands_check:
print '['+source_id+'] No data found in target directory for current source.'
# Make null entries in tables, as necessary
if kwargs_dict['fit_apertures']==True:
null_aperture_combined = [np.NaN, np.NaN, np.NaN, np.NaN]
CAAPR.CAAPR_IO.RecordAperture(null_aperture_combined, source_dict, kwargs_dict)
if kwargs_dict['do_photom']==True:
CAAPR.CAAPR_IO.RecordPhotom([], source_dict, bands_dict, kwargs_dict)
# Return result
if True not in bands_check:
return False
elif True in bands_check:
return True
# Define function that does basic initial handling of band parameters
def BandInitiate(band_dict):
# Make sure band has content
if band_dict==None:
return band_dict
# Parse band cutout request, converting string to boolean if necessary
if band_dict['make_cutout']=='True':
band_dict['make_cutout']=True
elif band_dict['make_cutout']=='False':
band_dict['make_cutout']=False
else:
try:
band_dict['make_cutout'] = float(band_dict['make_cutout'])
except:
raise Exception('Cutout request not understood; should either be False, or width of cutout in arcseconds.')
# Reset band directory to inviolate value, to purge any holdovers from previous source
band_dict['band_dir'] = band_dict['band_dir_inviolate']
# Return band dict
return band_dict
# Define function that performs preimilary checks of file type and location
def FilePrelim(source_dict, band_dict, kwargs_dict):
# Determine whether the user is specificing a directroy full of FITS files in this band (in which case use standardised filename format), or just a single FITS file
try:
if os.path.isdir(band_dict['band_dir']):
in_fitspath = os.path.join( band_dict['band_dir'], source_dict['name']+'_'+band_dict['band_name'] )
elif os.path.isfile(band_dict['band_dir']):
in_fitspath = os.path.join( band_dict['band_dir'] )
except:
pdb.set_trace()
# Work out whether the file extension for FITS file in question is .fits or .fits.gz
file_found = False
try:
if os.path.exists(in_fitspath+'.fits'):
in_fitspath = in_fitspath+'.fits'
file_found = True
elif os.path.exists(in_fitspath+'.fits.gz'):
in_fitspath = in_fitspath+'.fits.gz'
file_found = True
except:
raise Exception('Path provided for band '+str(band_dict['band_name'])+' refers to neither a file nor a folder.')
# Return file values
return in_fitspath, file_found
# Initiate the pod (Photometry Organisation Dictionary)
def PodInitiate(in_fitspath, source_dict, band_dict, kwargs_dict):
source_id = source_dict['name']+'_'+band_dict['band_name']
if kwargs_dict['verbose']: print '['+source_id+'] Reading in FITS data.'
# Read in FITS file in question
in_fitsdata = astropy.io.fits.open(in_fitspath)
in_image = in_fitsdata[0].data
in_header = in_fitsdata[0].header
in_fitsdata.close()
in_wcs = astropy.wcs.WCS(in_header)
in_fitspath_size = float(os.stat(in_fitspath).st_size)
# Create the pod (Photometry Organisation Dictionary), which will bundle all the photometry data for this source & band into one dictionary to be passed between functions
pod = {'in_fitspath':in_fitspath,
'in_image':in_image,
'in_header':in_header,
'in_wcs':in_wcs,
'cutout':in_image.copy(),
'output_dir_path':kwargs_dict['output_dir_path'],
'temp_dir_path':kwargs_dict['temp_dir_path'],
'in_fitspath_size':in_fitspath_size,
'id':source_id,
'verbose':kwargs_dict['verbose']}
# Return pod
return pod
# Define function that determines preliminary map values
def MapPrelim(pod, source_dict, band_dict, verbose=False):
|
if pod['verbose']: print '['+pod['id']+'] Determining properties of map.'
# Check if x & y pixel sizes are meaningfully different. If so, panic; else, treat as same
pix_size = 3600.0 * pod['in_wcs'].wcs.cdelt
if float(abs(pix_size.max()))/float(abs(pix_size.min()))>(1+1E-3):
raise Exception('The x pixel size if noticably different from the y pixel size.')
else:
pod['pix_arcsec'] = float(np.mean(np.abs(pix_size)))
# Determine source position in cutout in ij coordinates, and size of cutout
centre_xy = pod['in_wcs'].wcs_world2pix( np.array([[ source_dict['ra'], source_dict['dec'] ]]), 0 )
pod['centre_i'], pod['centre_j'] = float(centre_xy[0][1]), float(centre_xy[0][0])
pod['box_rad'] = int( round( float(pod['cutout'].shape[0]) * 0.5 ) )
# Determine beam size in pixels; if beam size not given, then assume map is Nyquist sampled (ie, 2.355 pixels ber beam)
if isinstance(band_dict['beam_arcsec'], numbers.Number):
pod['beam_pix'] = float(band_dict['beam_arcsec']) / pod['pix_arcsec']
else:
|
identifier_body
|
|
CAAPR_Pipeline.py
|
, source_dict, kwargs_dict)
# Record aperture properties to file
CAAPR.CAAPR_IO.RecordAperture(aperture_combined, source_dict, kwargs_dict)
# Prepare thumbnail images for bands excluded from aperture fitting
CAAPR.CAAPR_Aperture.ExcludedThumb(source_dict, bands_dict, kwargs_dict, aperture_list, aperture_combined)
# Create grid of thumbnail images
CAAPR.CAAPR_IO.ApertureThumbGrid(source_dict, bands_dict, kwargs_dict, aperture_list, aperture_combined)
# Report time taken to fit apertures, and tidy up garbage
gc.collect()
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Time taken performing aperture fitting: '+str(ChrisFuncs.FromGitHub.randlet.ToPrecision(time.time()-aperture_start,4))+' seconds.'
# Commence actual photometry sub-pipeline
if kwargs_dict['do_photom'] or kwargs_dict['save_images']:
# Handle problem where the user hasn't provided an aperture file, but also hasn't told CAAPR to fit its own apertures.
if kwargs_dict['aperture_table_path']==False and kwargs_dict['fit_apertures']==False:
raise Exception('User has requested no aperture-fitting, and no photometry!')
# Process sources inside while loop, to catch 'missed' bands
photom_attempts = 0
while photom_attempts!='Complete':
# In standard operation, process multiple sources in parallel
photom_start = time.time()
photom_output_list = []
if kwargs_dict['parallel']==True:
bands_dict_keys = bands_dict.keys()
random.shuffle(bands_dict_keys)
pool = mp.Pool(processes=kwargs_dict['n_proc'])
for band in bands_dict_keys:
photom_output_list.append( pool.apply_async( CAAPR.CAAPR_Photom.SubpipelinePhotom, args=(source_dict, bands_dict[band], kwargs_dict) ) )
pool.close()
pool.join()
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Gathering parallel threads.'
photom_output_list = [output.get() for output in photom_output_list if output.successful()==True]
photom_list = [photom for photom in photom_output_list if photom!=None]
# If parallelisation is disabled, process sources one-at-a-time
elif kwargs_dict['parallel']==False:
for band in bands_dict.keys():
photom_output_list.append( CAAPR.CAAPR_Photom.SubpipelinePhotom(source_dict, bands_dict[band], kwargs_dict) )
photom_list = [photom for photom in photom_output_list if photom!=None]
# Shortcut if no photometry is done
if not kwargs_dict['do_photom']:
photom_attempts = 'Complete'
gc.collect()
return
# Check that all photometry completed
photom_attempts, photom_output_list = CAAPR.CAAPR_Photom.PhotomCheck(photom_attempts, photom_output_list, source_dict, bands_dict, kwargs_dict)
# Record photometry results to file
CAAPR.CAAPR_IO.RecordPhotom(photom_list, source_dict, bands_dict, kwargs_dict)
# Prepare thumbnail images for bands excluded from photometry
CAAPR.CAAPR_Photom.ExcludedThumb(source_dict, bands_dict, kwargs_dict)
# Create grid of thumbnail images
CAAPR.CAAPR_IO.PhotomThumbGrid(source_dict, bands_dict, kwargs_dict)
# Report time taken to do photometry, and tidy up
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Time taken performing actual photometry: '+str(ChrisFuncs.FromGitHub.randlet.ToPrecision(time.time()-photom_start,4))+' seconds.'
# Tidy up temporary files and paths
bands_dict = PathTidy(source_dict, bands_dict, kwargs_dict)
# Report time taken for source, and tidy up garbage
gc.collect()
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Total time taken for souce: '+str(ChrisFuncs.FromGitHub.randlet.ToPrecision(time.time()-source_start,4))+' seconds.'
if kwargs_dict['thumbnails']==True and kwargs_dict['messy']==False:
[os.remove(os.path.join(kwargs_dict['temp_dir_path'],'Processed_Maps',processed_map)) for processed_map in os.listdir(os.path.join(kwargs_dict['temp_dir_path'],'Processed_Maps')) if '.fits' in processed_map]
# Define function to check if data actually exists for any band for this source
def SourcePrelim(source_dict, bands_dict, kwargs_dict):
# Check that any of the bands actually have data for this source
kwargs_dict_copy = copy.deepcopy(kwargs_dict)
kwargs_dict_copy['verbose'] = False
bands_check = []
for band in bands_dict.keys():
source_id = source_dict['name']+'_'+bands_dict[band]['band_name']
in_fitspath, file_found = CAAPR.CAAPR_Pipeline.FilePrelim(source_dict, bands_dict[band], kwargs_dict_copy)
bands_check.append(file_found)
# Report to user if no data found
if True not in bands_check:
print '['+source_id+'] No data found in target directory for current source.'
# Make null entries in tables, as necessary
if kwargs_dict['fit_apertures']==True:
null_aperture_combined = [np.NaN, np.NaN, np.NaN, np.NaN]
CAAPR.CAAPR_IO.RecordAperture(null_aperture_combined, source_dict, kwargs_dict)
if kwargs_dict['do_photom']==True:
CAAPR.CAAPR_IO.RecordPhotom([], source_dict, bands_dict, kwargs_dict)
# Return result
if True not in bands_check:
return False
elif True in bands_check:
return True
# Define function that does basic initial handling of band parameters
def BandInitiate(band_dict):
# Make sure band has content
if band_dict==None:
return band_dict
# Parse band cutout request, converting string to boolean if necessary
if band_dict['make_cutout']=='True':
band_dict['make_cutout']=True
elif band_dict['make_cutout']=='False':
band_dict['make_cutout']=False
else:
try:
band_dict['make_cutout'] = float(band_dict['make_cutout'])
except:
raise Exception('Cutout request not understood; should either be False, or width of cutout in arcseconds.')
# Reset band directory to inviolate value, to purge any holdovers from previous source
band_dict['band_dir'] = band_dict['band_dir_inviolate']
# Return band dict
return band_dict
# Define function that performs preimilary checks of file type and location
def
|
(source_dict, band_dict, kwargs_dict):
# Determine whether the user is specificing a directroy full of FITS files in this band (in which case use standardised filename format), or just a single FITS file
try:
if os.path.isdir(band_dict['band_dir']):
in_fitspath = os.path.join( band_dict['band_dir'], source_dict['name']+'_'+band_dict['band_name'] )
elif os.path.isfile(band_dict['band_dir']):
in_fitspath = os.path.join( band_dict['band_dir'] )
except:
pdb.set_trace()
# Work out whether the file extension for FITS file in question is .fits or .fits.gz
file_found = False
try:
if os.path.exists(in_fitspath+'.fits'):
in_fitspath = in_fitspath+'.fits'
file_found = True
elif os.path.exists(in_fitspath+'.fits.gz'):
in_fitspath = in_fitspath+'.fits.gz'
file_found = True
except:
raise Exception('Path provided for band '+str(band_dict['band_name'])+' refers to neither a file nor a folder.')
# Return file values
return in_fitspath, file_found
# Initiate the pod (Photometry Organisation Dictionary)
def PodInitiate(in_fitspath, source_dict, band_dict, kwargs_dict):
source_id = source_dict['name']+'_'+band_dict['band_name']
if kwargs_dict['verbose']: print '['+source_id+'] Reading in FITS data.'
# Read in FITS file in question
in_fitsdata = astropy.io.fits.open(in_fitspath)
in_image = in_fitsdata[0].data
in_header = in_fitsdata[0].header
in_fitsdata.close()
in_wcs = astropy.wcs.WCS(in_header)
in_fitspath_size = float(os.stat(in_fitspath).st_size)
# Create the pod (Photometry Organisation Dictionary), which will bundle all the photometry data for this source & band into one dictionary to be passed between functions
pod = {'in_fitspath':in_fitspath,
'in_image':in_image,
'in_header':in_header,
'in_wcs':in_wcs,
'cutout':in_image.copy(),
'output_dir_path':kwargs_dict['output_dir_path'],
'temp
|
FilePrelim
|
identifier_name
|
CAAPR_Pipeline.py
|
format), or just a single FITS file
try:
if os.path.isdir(band_dict['band_dir']):
in_fitspath = os.path.join( band_dict['band_dir'], source_dict['name']+'_'+band_dict['band_name'] )
elif os.path.isfile(band_dict['band_dir']):
in_fitspath = os.path.join( band_dict['band_dir'] )
except:
pdb.set_trace()
# Work out whether the file extension for FITS file in question is .fits or .fits.gz
file_found = False
try:
if os.path.exists(in_fitspath+'.fits'):
in_fitspath = in_fitspath+'.fits'
file_found = True
elif os.path.exists(in_fitspath+'.fits.gz'):
in_fitspath = in_fitspath+'.fits.gz'
file_found = True
except:
raise Exception('Path provided for band '+str(band_dict['band_name'])+' refers to neither a file nor a folder.')
# Return file values
return in_fitspath, file_found
# Initiate the pod (Photometry Organisation Dictionary)
def PodInitiate(in_fitspath, source_dict, band_dict, kwargs_dict):
source_id = source_dict['name']+'_'+band_dict['band_name']
if kwargs_dict['verbose']: print '['+source_id+'] Reading in FITS data.'
# Read in FITS file in question
in_fitsdata = astropy.io.fits.open(in_fitspath)
in_image = in_fitsdata[0].data
in_header = in_fitsdata[0].header
in_fitsdata.close()
in_wcs = astropy.wcs.WCS(in_header)
in_fitspath_size = float(os.stat(in_fitspath).st_size)
# Create the pod (Photometry Organisation Dictionary), which will bundle all the photometry data for this source & band into one dictionary to be passed between functions
pod = {'in_fitspath':in_fitspath,
'in_image':in_image,
'in_header':in_header,
'in_wcs':in_wcs,
'cutout':in_image.copy(),
'output_dir_path':kwargs_dict['output_dir_path'],
'temp_dir_path':kwargs_dict['temp_dir_path'],
'in_fitspath_size':in_fitspath_size,
'id':source_id,
'verbose':kwargs_dict['verbose']}
# Return pod
return pod
# Define function that determines preliminary map values
def MapPrelim(pod, source_dict, band_dict, verbose=False):
if pod['verbose']: print '['+pod['id']+'] Determining properties of map.'
# Check if x & y pixel sizes are meaningfully different. If so, panic; else, treat as same
pix_size = 3600.0 * pod['in_wcs'].wcs.cdelt
if float(abs(pix_size.max()))/float(abs(pix_size.min()))>(1+1E-3):
raise Exception('The x pixel size if noticably different from the y pixel size.')
else:
pod['pix_arcsec'] = float(np.mean(np.abs(pix_size)))
# Determine source position in cutout in ij coordinates, and size of cutout
centre_xy = pod['in_wcs'].wcs_world2pix( np.array([[ source_dict['ra'], source_dict['dec'] ]]), 0 )
pod['centre_i'], pod['centre_j'] = float(centre_xy[0][1]), float(centre_xy[0][0])
pod['box_rad'] = int( round( float(pod['cutout'].shape[0]) * 0.5 ) )
# Determine beam size in pixels; if beam size not given, then assume map is Nyquist sampled (ie, 2.355 pixels ber beam)
if isinstance(band_dict['beam_arcsec'], numbers.Number):
pod['beam_pix'] = float(band_dict['beam_arcsec']) / pod['pix_arcsec']
else:
pod['beam_pix'] = pod['pix_arcsec'] * 2.355
# Check if current source lies within bounds of map; if not, fai and return)
if pod['centre_i']<0 or pod['centre_i']>(pod['cutout'].shape)[0] or pod['centre_j']<0 or pod['centre_j']>(pod['cutout'].shape)[1]:
pod['within_bounds'] = False
if 'band_dir_inviolate' in band_dict.keys():
band_dict['band_dir'] = band_dict['band_dir_inviolate']
if pod['verbose']: print '['+pod['id']+'] Target not within bounds of map.'
else:
pod['within_bounds'] = True
# Return pod
return pod
# Define function that fits and subtracts polynomial background filter from map
def PolySub(pod, mask_semimaj_pix, mask_axial_ratio, mask_angle, poly_order=5, cutoff_sigma=2.0, instant_quit=False):
if pod['verbose']: print '['+pod['id']+'] Determining if (and how) background is significnatly variable.'
# If polynomial background subraction not wanted, immediately return everything unchanged
if instant_quit:
pod['sky_poly'] = False
return pod
# If image has pixels smaller than some limit, downsample image to improve processing time
pix_size = pod['pix_arcsec']
pix_size_limit = 2.0
if pix_size<pix_size_limit:
downsample_factor = int(np.ceil(pix_size_limit/pix_size))
else:
downsample_factor = 1
image_ds = ChrisFuncs.Downsample(pod['cutout'], downsample_factor)
# Downsample related values accordingly
mask_semimaj_pix = mask_semimaj_pix / downsample_factor
centre_i = int(round(float((0.5*pod['centre_i'])-1.0)))
centre_j = int(round(float((0.5*pod['centre_j'])-1.0)))
# Find cutoff for excluding bright pixels by sigma-clipping map
clip_value = ChrisFuncs.SigmaClip(image_ds, tolerance=0.01, sigma_thresh=3.0, median=True)
noise_value = clip_value[0]
field_value = clip_value[1]
cutoff = field_value + ( cutoff_sigma * noise_value )
# Mask all image pixels in masking region around source
image_masked = image_ds.copy()
ellipse_mask = ChrisFuncs.Photom.EllipseMask(image_ds, mask_semimaj_pix, mask_axial_ratio, mask_angle, centre_i, centre_j)
image_masked[ np.where( ellipse_mask==1 ) ] = np.nan
# Mask all image pixels identified as being high SNR
image_masked[ np.where( image_masked>cutoff ) ] = np.nan
# Use astropy to set up 2-dimensional polynomial to the image
image_masked[ np.where( np.isnan(image_masked)==True ) ] = field_value
poly_model = astropy.modeling.models.Polynomial2D(degree=poly_order)
i_coords, j_coords = np.mgrid[:image_masked.shape[0], :image_masked.shape[1]]
fitter = astropy.modeling.fitting.LevMarLSQFitter()
i_coords = i_coords.flatten()
j_coords = j_coords.flatten()
image_flattened = image_masked.flatten()
good = np.where(np.isnan(image_flattened)==False)
i_coords = i_coords[good]
j_coords = j_coords[good]
# Attempt polynomial fit; if insufficient data then skip onwards
image_flattened = image_flattened[good]
try:
fit = fitter(poly_model, i_coords, j_coords, image_flattened)
except:
if pod['verbose']: print '['+pod['id']+'] Background is not significnatly variable; leaving image unaltered.'
pod['sky_poly'] = False
return pod
# Create final polynomial filter (undoing downsampling using lorenzoriano GitHub script)
i_coords, j_coords = np.mgrid[:image_ds.shape[0], :image_ds.shape[1]]
poly_fit = fit(i_coords, j_coords)
poly_full = scipy.ndimage.interpolation.zoom(poly_fit, [ float(pod['cutout'].shape[0])/float(poly_fit.shape[0]), float(pod['cutout'].shape[1])/float(poly_fit.shape[1]) ], mode='nearest') #poly_full = congrid.congrid(poly_fit, (pod['cutout'].shape[0], pod['cutout'].shape[1]), minusone=True)
# Establish background variation before application of filter
sigma_thresh = 3.0
clip_in = ChrisFuncs.SigmaClip(pod['cutout'], tolerance=0.005, median=True, sigma_thresh=sigma_thresh)
bg_in = pod['cutout'][ np.where( pod['cutout']<clip_in[1] ) ]
|
spread_in = np.mean( np.abs( bg_in - clip_in[1] ) )
# How much reduction in background variation there was due to application of the filter
image_sub = pod['cutout'] - poly_full
|
random_line_split
|
|
CAAPR_Pipeline.py
|
, source_dict, kwargs_dict)
# Record aperture properties to file
CAAPR.CAAPR_IO.RecordAperture(aperture_combined, source_dict, kwargs_dict)
# Prepare thumbnail images for bands excluded from aperture fitting
CAAPR.CAAPR_Aperture.ExcludedThumb(source_dict, bands_dict, kwargs_dict, aperture_list, aperture_combined)
# Create grid of thumbnail images
CAAPR.CAAPR_IO.ApertureThumbGrid(source_dict, bands_dict, kwargs_dict, aperture_list, aperture_combined)
# Report time taken to fit apertures, and tidy up garbage
gc.collect()
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Time taken performing aperture fitting: '+str(ChrisFuncs.FromGitHub.randlet.ToPrecision(time.time()-aperture_start,4))+' seconds.'
# Commence actual photometry sub-pipeline
if kwargs_dict['do_photom'] or kwargs_dict['save_images']:
# Handle problem where the user hasn't provided an aperture file, but also hasn't told CAAPR to fit its own apertures.
if kwargs_dict['aperture_table_path']==False and kwargs_dict['fit_apertures']==False:
raise Exception('User has requested no aperture-fitting, and no photometry!')
# Process sources inside while loop, to catch 'missed' bands
photom_attempts = 0
while photom_attempts!='Complete':
# In standard operation, process multiple sources in parallel
photom_start = time.time()
photom_output_list = []
if kwargs_dict['parallel']==True:
bands_dict_keys = bands_dict.keys()
random.shuffle(bands_dict_keys)
pool = mp.Pool(processes=kwargs_dict['n_proc'])
for band in bands_dict_keys:
photom_output_list.append( pool.apply_async( CAAPR.CAAPR_Photom.SubpipelinePhotom, args=(source_dict, bands_dict[band], kwargs_dict) ) )
pool.close()
pool.join()
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Gathering parallel threads.'
photom_output_list = [output.get() for output in photom_output_list if output.successful()==True]
photom_list = [photom for photom in photom_output_list if photom!=None]
# If parallelisation is disabled, process sources one-at-a-time
elif kwargs_dict['parallel']==False:
for band in bands_dict.keys():
photom_output_list.append( CAAPR.CAAPR_Photom.SubpipelinePhotom(source_dict, bands_dict[band], kwargs_dict) )
photom_list = [photom for photom in photom_output_list if photom!=None]
# Shortcut if no photometry is done
if not kwargs_dict['do_photom']:
photom_attempts = 'Complete'
gc.collect()
return
# Check that all photometry completed
photom_attempts, photom_output_list = CAAPR.CAAPR_Photom.PhotomCheck(photom_attempts, photom_output_list, source_dict, bands_dict, kwargs_dict)
# Record photometry results to file
CAAPR.CAAPR_IO.RecordPhotom(photom_list, source_dict, bands_dict, kwargs_dict)
# Prepare thumbnail images for bands excluded from photometry
CAAPR.CAAPR_Photom.ExcludedThumb(source_dict, bands_dict, kwargs_dict)
# Create grid of thumbnail images
CAAPR.CAAPR_IO.PhotomThumbGrid(source_dict, bands_dict, kwargs_dict)
# Report time taken to do photometry, and tidy up
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Time taken performing actual photometry: '+str(ChrisFuncs.FromGitHub.randlet.ToPrecision(time.time()-photom_start,4))+' seconds.'
# Tidy up temporary files and paths
bands_dict = PathTidy(source_dict, bands_dict, kwargs_dict)
# Report time taken for source, and tidy up garbage
gc.collect()
if kwargs_dict['verbose']: print '['+source_dict['name']+'] Total time taken for souce: '+str(ChrisFuncs.FromGitHub.randlet.ToPrecision(time.time()-source_start,4))+' seconds.'
if kwargs_dict['thumbnails']==True and kwargs_dict['messy']==False:
[os.remove(os.path.join(kwargs_dict['temp_dir_path'],'Processed_Maps',processed_map)) for processed_map in os.listdir(os.path.join(kwargs_dict['temp_dir_path'],'Processed_Maps')) if '.fits' in processed_map]
# Define function to check if data actually exists for any band for this source
def SourcePrelim(source_dict, bands_dict, kwargs_dict):
# Check that any of the bands actually have data for this source
kwargs_dict_copy = copy.deepcopy(kwargs_dict)
kwargs_dict_copy['verbose'] = False
bands_check = []
for band in bands_dict.keys():
source_id = source_dict['name']+'_'+bands_dict[band]['band_name']
in_fitspath, file_found = CAAPR.CAAPR_Pipeline.FilePrelim(source_dict, bands_dict[band], kwargs_dict_copy)
bands_check.append(file_found)
# Report to user if no data found
if True not in bands_check:
|
# Return result
if True not in bands_check:
return False
elif True in bands_check:
return True
# Define function that does basic initial handling of band parameters
def BandInitiate(band_dict):
# Make sure band has content
if band_dict==None:
return band_dict
# Parse band cutout request, converting string to boolean if necessary
if band_dict['make_cutout']=='True':
band_dict['make_cutout']=True
elif band_dict['make_cutout']=='False':
band_dict['make_cutout']=False
else:
try:
band_dict['make_cutout'] = float(band_dict['make_cutout'])
except:
raise Exception('Cutout request not understood; should either be False, or width of cutout in arcseconds.')
# Reset band directory to inviolate value, to purge any holdovers from previous source
band_dict['band_dir'] = band_dict['band_dir_inviolate']
# Return band dict
return band_dict
# Define function that performs preimilary checks of file type and location
def FilePrelim(source_dict, band_dict, kwargs_dict):
# Determine whether the user is specificing a directroy full of FITS files in this band (in which case use standardised filename format), or just a single FITS file
try:
if os.path.isdir(band_dict['band_dir']):
in_fitspath = os.path.join( band_dict['band_dir'], source_dict['name']+'_'+band_dict['band_name'] )
elif os.path.isfile(band_dict['band_dir']):
in_fitspath = os.path.join( band_dict['band_dir'] )
except:
pdb.set_trace()
# Work out whether the file extension for FITS file in question is .fits or .fits.gz
file_found = False
try:
if os.path.exists(in_fitspath+'.fits'):
in_fitspath = in_fitspath+'.fits'
file_found = True
elif os.path.exists(in_fitspath+'.fits.gz'):
in_fitspath = in_fitspath+'.fits.gz'
file_found = True
except:
raise Exception('Path provided for band '+str(band_dict['band_name'])+' refers to neither a file nor a folder.')
# Return file values
return in_fitspath, file_found
# Initiate the pod (Photometry Organisation Dictionary)
def PodInitiate(in_fitspath, source_dict, band_dict, kwargs_dict):
source_id = source_dict['name']+'_'+band_dict['band_name']
if kwargs_dict['verbose']: print '['+source_id+'] Reading in FITS data.'
# Read in FITS file in question
in_fitsdata = astropy.io.fits.open(in_fitspath)
in_image = in_fitsdata[0].data
in_header = in_fitsdata[0].header
in_fitsdata.close()
in_wcs = astropy.wcs.WCS(in_header)
in_fitspath_size = float(os.stat(in_fitspath).st_size)
# Create the pod (Photometry Organisation Dictionary), which will bundle all the photometry data for this source & band into one dictionary to be passed between functions
pod = {'in_fitspath':in_fitspath,
'in_image':in_image,
'in_header':in_header,
'in_wcs':in_wcs,
'cutout':in_image.copy(),
'output_dir_path':kwargs_dict['output_dir_path'],
'temp
|
print '['+source_id+'] No data found in target directory for current source.'
# Make null entries in tables, as necessary
if kwargs_dict['fit_apertures']==True:
null_aperture_combined = [np.NaN, np.NaN, np.NaN, np.NaN]
CAAPR.CAAPR_IO.RecordAperture(null_aperture_combined, source_dict, kwargs_dict)
if kwargs_dict['do_photom']==True:
CAAPR.CAAPR_IO.RecordPhotom([], source_dict, bands_dict, kwargs_dict)
|
conditional_block
|
index.js
|
var btnRule = pageRule.querySelector('.bottom-btn img');
var btnQuestion1 = pageQuestion1.querySelector('.bottom-btn img');
var btnGifPlay = pageQuestion1.querySelector('.btn-play');
var btnGifImg = pageQuestion1.querySelector('.gif-img');
var btnQuestion2 = pageQuestion2.querySelector('.bottom-btn img');
var btnRestart = pageFail.querySelector('.bottom-btn img');
var btnZhizhen = pageReward.querySelector('.zhizhen');
var btnAgain = pageAgain.querySelector('.bottom-btn img');
var btnMessages = pageMessages.querySelector('.bottom-btn img');
var jiangpinImg = pageMessages.querySelector('.jiangpin img');
var jiangpinName = pageMessages.querySelector('.jiangpin p');
var answer1 = '';
var answer2 = {};
var currentMaster = 1;
var reward = '';
//云朵飘动
function yunduo() {
yun1Left++;
yun1.style.left = -yun1Left+'px';
yun2.style.left = (yun2Left-yun1Left)+'px';
if(yun1Left > yun2Left){
yun1Left = 0;
}
requestAnimationFrame(yunduo);
}
//隐藏系统alerturl
window.alert = function(name){
var iframe = document.createElement("IFRAME");
iframe.style.display="none";
iframe.setAttribute("src", 'data:text/plain,');
document.documentElement.appendChild(iframe);
window.frames[0].window.alert(name);
iframe.parentNode.removeChild(iframe);
};
//预加载
var imgArr = [
'img/answer1-gif.gif',
'img/answer1-gif-1.jpg',
'img/img-index.png',
'img/bg-messages.png',
'img/bg-question1.png',
'img/bg-question2.png',
'img/bg-rule.png',
'img/bg-zhuanpan.png',
'img/1.jpg',
'img/2.png',
'img/3.jpg',
'img/4.jpg',
'img/wxicon.jpg'
];
var loading = document.querySelector('.loading');
var loadingPro = loading.querySelector('.top');
var imgArrLength = imgArr.length;
var imageKey = 0;
imgArr.forEach(function (val,key) {
var oImg = new Image();
oImg.onload = function(){
oImg.onload = null;
loadingPro.style.width = Math.ceil(100*(++imageKey)/imgArrLength)+'%';
if (imageKey == imgArrLength) {
$('.preload-bg').each(function (i,v) {
v.style.backgroundImage = 'url('+v.dataset.preload_src+')';
});
$('.preload-img').each(function (i,v) {
v.src = v.dataset.preload_src;
});
loading.classList.add('none');
pageIndex.classList.remove('none');
// pageReward.classList.remove('none');
// pageMessages.classList.remove('none');
requestAnimationFrame(yunduo);
document.addEventListener("WeixinJSBridgeReady", function () {//微信
bgMusic.play();
}, false);
}
};
oImg.src = val;
});
btnStart.onclick = function () {
btnAudio.play();
pageIndex.classList.add('none');
pageRule.classList.remove('none');
};
btnRule.onclick = function () {
btnAudio.play();
pageRule.classList.add('none');
pageQuestion1.classList.remove('none');
};
//问题一选答案并记录
$('#question1 .answer1').each(function (i,val) {
val.onclick =function () {
btnAudio.play();
$('#question1 .answer1').each(function (i,v) {
v.classList.remove('active');
});
val.classList.add('active');
answer1 = val.dataset.value;
}
});
//问题一点击按钮播放
btnGifPlay.onclick = function () {
btnAudio.play();
var _this = this;
var src = btnGifImg.src;
var dataSrc = btnGifImg.dataset.src;
_this.classList.add('none');
setTimeout(function () {
btnGifImg.src = dataSrc;
},500);
setTimeout(function () {
_this.classList.remove('none');
btnGifImg.src = src;
},9500);
};
btnQuestion1.onclick = function () {
btnAudio.play();
if (answer1) {
pageQuestion1.classList.add('none');
pageQuestion2.classList.remove('none');
}
};
//问题二选和尚
$('.master-small img').each(function (key,val) {
val.onclick =function () {
btnAudio.play();
$('.bingqi img').each(function (i,v) {
v.classList.remove('active');
});
if (answer2['as'+(key+1)]) {
pageQuestion2.querySelectorAll('.bingqi img')[answer2['as'+(key+1)]-1].classList.add('active');
}
$('.master-small img').each(function (i,v) {
v.classList.remove('active');
});
val.classList.add('active');
$('.master-big').each(function (i,v) {
v.classList.add('none');
});
pageQuestion2.querySelectorAll('.master-big')[key].classList.remove('none');
currentMaster = key+1;
}
});
//问题二选兵器
$('.bingqi img').each(function (key,val) {
val.onclick = function () {
btnAudio.play();
pageQuestion2.querySelectorAll('.bingqi img').forEach(function (v) {
v.classList.remove('active');
});
val.classList.add('active');
answer2['as'+currentMaster] = key+1;
}
});
btnQuestion2.onclick = function () {
btnAudio.play();
if (answer2.as3 && answer2.as1 && answer2.as2) {
if ((answer2.as1 === 1) && (answer2.as2 === 2) && (answer2.as3 === 4) && (answer1=='c')) {
pageQuestion2.classList.add('none');
pageReward.classList.remove('none');
} else {
pageFail.classList.remove('none');
}
}
else {
alert ('注意！三位大师都要匹配相应兵器哦~');
}
};
//重新开始
btnRestart.onclick = function () {
btnAudio.play();
pageFail.classList.add('none');
pageIndex.classList.remove('none');
//清空之前答案
pageQuestion1.querySelectorAll('.answer1').forEach(function (v) {
v.classList.remove('active');
});
answer1 = '';
pageQuestion2.querySelectorAll('.master-small img').forEach(function (v) {
v.classList.remove('active');
});
pageQuestion2.querySelectorAll('.master-small img')[0].classList.add('active');
pageQuestion2.querySelectorAll('.bingqi img').forEach(function (v) {
v.classList.remove('active');
});
answer2 = {};
currentMaster = 1;
};
//抽奖
var is_click = 1;
btnZhizhen.onclick = function () {
btnAudio.play();
if (!is_click) {
return false;
}
var _this = this;
var zhongjiang = 1;
is_click = 0;
//请求抽奖结果决定停止位置
$.ajax({
type: 'post',
url: 'https://wx.ouu.me/home/getHomeLuckdraw',
data: {
openid: open_id
},
dataType: 'json',
success: function(data){
reward = data.date.yes || '5';
if (reward == '1') {
_this.classList.add('yideng');
jiangpinImg.src = 'img/1.jpg';
jiangpinName.innerHTML = '昂坪360 精美行李带<span>（价值HK$120）</span>';
} else if(reward == '2') {
var erdeng = (Math.random()>0.5)? 'erdeng1':'erdeng2';
_this.classList.add(erdeng);
jiangpinImg.src = 'img/2.png';
jiangpinName.innerHTML = '昂坪360 化妆品收纳袋<span>（价值HK$120）</span>';
} else if(reward == '3') {
var sandeng = (Math.random()>0.5)? 'sandeng1':'sandeng2';
_this.classList.add(sandeng);
jiangpinImg.src = 'img/3.jpg';
jiangpinName.innerHTML = '昂坪360 缆车小钱包<span>（价值HK$130）</span>';
} else if(reward == '4') {
var youxiu = (Math.random()>0.5)? 'youxiu1':'youxiu2';
_this.classList.add(youxiu);
jiangpinImg.src = 'img/4.jpg';
jiangpinName.innerHTML = '驴妈妈 小驴公仔';
} else {
var xiexie = (Math.random()>0.5)? 'xiexie1':'xiexie2';
_this.classList.add(xiexie);
zhongjiang = 0
}
setTimeout
|
var yun1Left = 0;
var yun2Left = parseInt(window.getComputedStyle(yun2).left);
var btnStart = pageIndex.querySelector('.bottom-btn img');
|
random_line_split
|
|
index.js
|
ifImg = pageQuestion1.querySelector('.gif-img');
var btnQuestion2 = pageQuestion2.querySelector('.bottom-btn img');
var btnRestart = pageFail.querySelector('.bottom-btn img');
var btnZhizhen = pageReward.querySelector('.zhizhen');
var btnAgain = pageAgain.querySelector('.bottom-btn img');
var btnMessages = pageMessages.querySelector('.bottom-btn img');
var jiangpinImg = pageMessages.querySelector('.jiangpin img');
var jiangpinName = pageMessages.querySelector('.jiangpin p');
var answer1 = '';
var answer2 = {};
var currentMaster = 1;
var reward = '';
//云朵飘动
function yunduo()
|
yun1Left++;
yun1.style.left = -yun1Left+'px';
yun2.style.left = (yun2Left-yun1Left)+'px';
if(yun1Left > yun2Left){
yun1Left = 0;
}
requestAnimationFrame(yunduo);
}
//隐藏系统alerturl
window.alert = function(name){
var iframe = document.createElement("IFRAME");
iframe.style.display="none";
iframe.setAttribute("src", 'data:text/plain,');
document.documentElement.appendChild(iframe);
window.frames[0].window.alert(name);
iframe.parentNode.removeChild(iframe);
};
//预加载
var imgArr = [
'img/answer1-gif.gif',
'img/answer1-gif-1.jpg',
'img/img-index.png',
'img/bg-messages.png',
'img/bg-question1.png',
'img/bg-question2.png',
'img/bg-rule.png',
'img/bg-zhuanpan.png',
'img/1.jpg',
'img/2.png',
'img/3.jpg',
'img/4.jpg',
'img/wxicon.jpg'
];
var loading = document.querySelector('.loading');
var loadingPro = loading.querySelector('.top');
var imgArrLength = imgArr.length;
var imageKey = 0;
imgArr.forEach(function (val,key) {
var oImg = new Image();
oImg.onload = function(){
oImg.onload = null;
loadingPro.style.width = Math.ceil(100*(++imageKey)/imgArrLength)+'%';
if (imageKey == imgArrLength) {
$('.preload-bg').each(function (i,v) {
v.style.backgroundImage = 'url('+v.dataset.preload_src+')';
});
$('.preload-img').each(function (i,v) {
v.src = v.dataset.preload_src;
});
loading.classList.add('none');
pageIndex.classList.remove('none');
// pageReward.classList.remove('none');
// pageMessages.classList.remove('none');
requestAnimationFrame(yunduo);
document.addEventListener("WeixinJSBridgeReady", function () {//微信
bgMusic.play();
}, false);
}
};
oImg.src = val;
});
btnStart.onclick = function () {
btnAudio.play();
pageIndex.classList.add('none');
pageRule.classList.remove('none');
};
btnRule.onclick = function () {
btnAudio.play();
pageRule.classList.add('none');
pageQuestion1.classList.remove('none');
};
//问题一选答案并记录
$('#question1 .answer1').each(function (i,val) {
val.onclick =function () {
btnAudio.play();
$('#question1 .answer1').each(function (i,v) {
v.classList.remove('active');
});
val.classList.add('active');
answer1 = val.dataset.value;
}
});
//问题一点击按钮播放
btnGifPlay.onclick = function () {
btnAudio.play();
var _this = this;
var src = btnGifImg.src;
var dataSrc = btnGifImg.dataset.src;
_this.classList.add('none');
setTimeout(function () {
btnGifImg.src = dataSrc;
},500);
setTimeout(function () {
_this.classList.remove('none');
btnGifImg.src = src;
},9500);
};
btnQuestion1.onclick = function () {
btnAudio.play();
if (answer1) {
pageQuestion1.classList.add('none');
pageQuestion2.classList.remove('none');
}
};
//问题二选和尚
$('.master-small img').each(function (key,val) {
val.onclick =function () {
btnAudio.play();
$('.bingqi img').each(function (i,v) {
v.classList.remove('active');
});
if (answer2['as'+(key+1)]) {
pageQuestion2.querySelectorAll('.bingqi img')[answer2['as'+(key+1)]-1].classList.add('active');
}
$('.master-small img').each(function (i,v) {
v.classList.remove('active');
});
val.classList.add('active');
$('.master-big').each(function (i,v) {
v.classList.add('none');
});
pageQuestion2.querySelectorAll('.master-big')[key].classList.remove('none');
currentMaster = key+1;
}
});
//问题二选兵器
$('.bingqi img').each(function (key,val) {
val.onclick = function () {
btnAudio.play();
pageQuestion2.querySelectorAll('.bingqi img').forEach(function (v) {
v.classList.remove('active');
});
val.classList.add('active');
answer2['as'+currentMaster] = key+1;
}
});
btnQuestion2.onclick = function () {
btnAudio.play();
if (answer2.as3 && answer2.as1 && answer2.as2) {
if ((answer2.as1 === 1) && (answer2.as2 === 2) && (answer2.as3 === 4) && (answer1=='c')) {
pageQuestion2.classList.add('none');
pageReward.classList.remove('none');
} else {
pageFail.classList.remove('none');
}
}
else {
alert ('注意！三位大师都要匹配相应兵器哦~');
}
};
//重新开始
btnRestart.onclick = function () {
btnAudio.play();
pageFail.classList.add('none');
pageIndex.classList.remove('none');
//清空之前答案
pageQuestion1.querySelectorAll('.answer1').forEach(function (v) {
v.classList.remove('active');
});
answer1 = '';
pageQuestion2.querySelectorAll('.master-small img').forEach(function (v) {
v.classList.remove('active');
});
pageQuestion2.querySelectorAll('.master-small img')[0].classList.add('active');
pageQuestion2.querySelectorAll('.bingqi img').forEach(function (v) {
v.classList.remove('active');
});
answer2 = {};
currentMaster = 1;
};
//抽奖
var is_click = 1;
btnZhizhen.onclick = function () {
btnAudio.play();
if (!is_click) {
return false;
}
var _this = this;
var zhongjiang = 1;
is_click = 0;
//请求抽奖结果决定停止位置
$.ajax({
type: 'post',
url: 'https://wx.ouu.me/home/getHomeLuckdraw',
data: {
openid: open_id
},
dataType: 'json',
success: function(data){
reward = data.date.yes || '5';
if (reward == '1') {
_this.classList.add('yideng');
jiangpinImg.src = 'img/1.jpg';
jiangpinName.innerHTML = '昂坪360 精美行李带<span>（价值HK$120）</span>';
} else if(reward == '2') {
var erdeng = (Math.random()>0.5)? 'erdeng1':'erdeng2';
_this.classList.add(erdeng);
jiangpinImg.src = 'img/2.png';
jiangpinName.innerHTML = '昂坪360 化妆品收纳袋<span>（价值HK$120）</span>';
} else if(reward == '3') {
var sandeng = (Math.random()>0.5)? 'sandeng1':'sandeng2';
_this.classList.add(sandeng);
jiangpinImg.src = 'img/3.jpg';
jiangpinName.innerHTML = '昂坪360 缆车小钱包<span>（价值HK$130）</span>';
} else if(reward == '4') {
var youxiu = (Math.random()>0.5)? 'youxiu1':'youxiu2';
_this.classList.add(youxiu);
jiangpinImg.src = 'img/4.jpg';
jiangpinName.innerHTML = '驴妈妈 小驴公仔';
} else {
var xiexie = (Math.random()>0.5)? 'xiexie1':'xiexie2';
_this.classList.add(xiexie);
zhongjiang = 0
}
setTimeout(function () {
if (zhongjiang) {
pageReward.classList.add('none');
pageMessages.classList.remove('none');
} else {
pageAgain.classList.remove('none');
}
},5200)
}
});
};
//再来一次
btnAgain.onclick = function () {
btnAudio.play();
btnZhizhen.className = 'zhizhen';
is_click
|
{
|
identifier_name
|
index.js
|
ifImg = pageQuestion1.querySelector('.gif-img');
var btnQuestion2 = pageQuestion2.querySelector('.bottom-btn img');
var btnRestart = pageFail.querySelector('.bottom-btn img');
var btnZhizhen = pageReward.querySelector('.zhizhen');
var btnAgain = pageAgain.querySelector('.bottom-btn img');
var btnMessages = pageMessages.querySelector('.bottom-btn img');
var jiangpinImg = pageMessages.querySelector('.jiangpin img');
var jiangpinName = pageMessages.querySelector('.jiangpin p');
var answer1 = '';
var answer2 = {};
var currentMaster = 1;
var reward = '';
//云朵飘动
function yunduo() {
yu
|
系统alerturl
window.alert = function(name){
var iframe = document.createElement("IFRAME");
iframe.style.display="none";
iframe.setAttribute("src", 'data:text/plain,');
document.documentElement.appendChild(iframe);
window.frames[0].window.alert(name);
iframe.parentNode.removeChild(iframe);
};
//预加载
var imgArr = [
'img/answer1-gif.gif',
'img/answer1-gif-1.jpg',
'img/img-index.png',
'img/bg-messages.png',
'img/bg-question1.png',
'img/bg-question2.png',
'img/bg-rule.png',
'img/bg-zhuanpan.png',
'img/1.jpg',
'img/2.png',
'img/3.jpg',
'img/4.jpg',
'img/wxicon.jpg'
];
var loading = document.querySelector('.loading');
var loadingPro = loading.querySelector('.top');
var imgArrLength = imgArr.length;
var imageKey = 0;
imgArr.forEach(function (val,key) {
var oImg = new Image();
oImg.onload = function(){
oImg.onload = null;
loadingPro.style.width = Math.ceil(100*(++imageKey)/imgArrLength)+'%';
if (imageKey == imgArrLength) {
$('.preload-bg').each(function (i,v) {
v.style.backgroundImage = 'url('+v.dataset.preload_src+')';
});
$('.preload-img').each(function (i,v) {
v.src = v.dataset.preload_src;
});
loading.classList.add('none');
pageIndex.classList.remove('none');
// pageReward.classList.remove('none');
// pageMessages.classList.remove('none');
requestAnimationFrame(yunduo);
document.addEventListener("WeixinJSBridgeReady", function () {//微信
bgMusic.play();
}, false);
}
};
oImg.src = val;
});
btnStart.onclick = function () {
btnAudio.play();
pageIndex.classList.add('none');
pageRule.classList.remove('none');
};
btnRule.onclick = function () {
btnAudio.play();
pageRule.classList.add('none');
pageQuestion1.classList.remove('none');
};
//问题一选答案并记录
$('#question1 .answer1').each(function (i,val) {
val.onclick =function () {
btnAudio.play();
$('#question1 .answer1').each(function (i,v) {
v.classList.remove('active');
});
val.classList.add('active');
answer1 = val.dataset.value;
}
});
//问题一点击按钮播放
btnGifPlay.onclick = function () {
btnAudio.play();
var _this = this;
var src = btnGifImg.src;
var dataSrc = btnGifImg.dataset.src;
_this.classList.add('none');
setTimeout(function () {
btnGifImg.src = dataSrc;
},500);
setTimeout(function () {
_this.classList.remove('none');
btnGifImg.src = src;
},9500);
};
btnQuestion1.onclick = function () {
btnAudio.play();
if (answer1) {
pageQuestion1.classList.add('none');
pageQuestion2.classList.remove('none');
}
};
//问题二选和尚
$('.master-small img').each(function (key,val) {
val.onclick =function () {
btnAudio.play();
$('.bingqi img').each(function (i,v) {
v.classList.remove('active');
});
if (answer2['as'+(key+1)]) {
pageQuestion2.querySelectorAll('.bingqi img')[answer2['as'+(key+1)]-1].classList.add('active');
}
$('.master-small img').each(function (i,v) {
v.classList.remove('active');
});
val.classList.add('active');
$('.master-big').each(function (i,v) {
v.classList.add('none');
});
pageQuestion2.querySelectorAll('.master-big')[key].classList.remove('none');
currentMaster = key+1;
}
});
//问题二选兵器
$('.bingqi img').each(function (key,val) {
val.onclick = function () {
btnAudio.play();
pageQuestion2.querySelectorAll('.bingqi img').forEach(function (v) {
v.classList.remove('active');
});
val.classList.add('active');
answer2['as'+currentMaster] = key+1;
}
});
btnQuestion2.onclick = function () {
btnAudio.play();
if (answer2.as3 && answer2.as1 && answer2.as2) {
if ((answer2.as1 === 1) && (answer2.as2 === 2) && (answer2.as3 === 4) && (answer1=='c')) {
pageQuestion2.classList.add('none');
pageReward.classList.remove('none');
} else {
pageFail.classList.remove('none');
}
}
else {
alert ('注意！三位大师都要匹配相应兵器哦~');
}
};
//重新开始
btnRestart.onclick = function () {
btnAudio.play();
pageFail.classList.add('none');
pageIndex.classList.remove('none');
//清空之前答案
pageQuestion1.querySelectorAll('.answer1').forEach(function (v) {
v.classList.remove('active');
});
answer1 = '';
pageQuestion2.querySelectorAll('.master-small img').forEach(function (v) {
v.classList.remove('active');
});
pageQuestion2.querySelectorAll('.master-small img')[0].classList.add('active');
pageQuestion2.querySelectorAll('.bingqi img').forEach(function (v) {
v.classList.remove('active');
});
answer2 = {};
currentMaster = 1;
};
//抽奖
var is_click = 1;
btnZhizhen.onclick = function () {
btnAudio.play();
if (!is_click) {
return false;
}
var _this = this;
var zhongjiang = 1;
is_click = 0;
//请求抽奖结果决定停止位置
$.ajax({
type: 'post',
url: 'https://wx.ouu.me/home/getHomeLuckdraw',
data: {
openid: open_id
},
dataType: 'json',
success: function(data){
reward = data.date.yes || '5';
if (reward == '1') {
_this.classList.add('yideng');
jiangpinImg.src = 'img/1.jpg';
jiangpinName.innerHTML = '昂坪360 精美行李带<span>（价值HK$120）</span>';
} else if(reward == '2') {
var erdeng = (Math.random()>0.5)? 'erdeng1':'erdeng2';
_this.classList.add(erdeng);
jiangpinImg.src = 'img/2.png';
jiangpinName.innerHTML = '昂坪360 化妆品收纳袋<span>（价值HK$120）</span>';
} else if(reward == '3') {
var sandeng = (Math.random()>0.5)? 'sandeng1':'sandeng2';
_this.classList.add(sandeng);
jiangpinImg.src = 'img/3.jpg';
jiangpinName.innerHTML = '昂坪360 缆车小钱包<span>（价值HK$130）</span>';
} else if(reward == '4') {
var youxiu = (Math.random()>0.5)? 'youxiu1':'youxiu2';
_this.classList.add(youxiu);
jiangpinImg.src = 'img/4.jpg';
jiangpinName.innerHTML = '驴妈妈 小驴公仔';
} else {
var xiexie = (Math.random()>0.5)? 'xiexie1':'xiexie2';
_this.classList.add(xiexie);
zhongjiang = 0
}
setTimeout(function () {
if (zhongjiang) {
pageReward.classList.add('none');
pageMessages.classList.remove('none');
} else {
pageAgain.classList.remove('none');
}
},5200)
}
});
};
//再来一次
btnAgain.onclick = function () {
btnAudio.play();
btnZhizhen.className = 'zhizhen';
is
|
n1Left++;
yun1.style.left = -yun1Left+'px';
yun2.style.left = (yun2Left-yun1Left)+'px';
if(yun1Left > yun2Left){
yun1Left = 0;
}
requestAnimationFrame(yunduo);
}
//隐藏
|
identifier_body
|
index.js
|
ifImg = pageQuestion1.querySelector('.gif-img');
var btnQuestion2 = pageQuestion2.querySelector('.bottom-btn img');
var btnRestart = pageFail.querySelector('.bottom-btn img');
var btnZhizhen = pageReward.querySelector('.zhizhen');
var btnAgain = pageAgain.querySelector('.bottom-btn img');
var btnMessages = pageMessages.querySelector('.bottom-btn img');
var jiangpinImg = pageMessages.querySelector('.jiangpin img');
var jiangpinName = pageMessages.querySelector('.jiangpin p');
var answer1 = '';
var answer2 = {};
var currentMaster = 1;
var reward = '';
//云朵飘动
function yunduo() {
yun1Left++;
yun1.style.left = -yun1Left+'px';
yun2.style.left = (yun2Left-yun1Left)+'px';
if(yun1Left > yun2Left){
|
uestAnimationFrame(yunduo);
}
//隐藏系统alerturl
window.alert = function(name){
var iframe = document.createElement("IFRAME");
iframe.style.display="none";
iframe.setAttribute("src", 'data:text/plain,');
document.documentElement.appendChild(iframe);
window.frames[0].window.alert(name);
iframe.parentNode.removeChild(iframe);
};
//预加载
var imgArr = [
'img/answer1-gif.gif',
'img/answer1-gif-1.jpg',
'img/img-index.png',
'img/bg-messages.png',
'img/bg-question1.png',
'img/bg-question2.png',
'img/bg-rule.png',
'img/bg-zhuanpan.png',
'img/1.jpg',
'img/2.png',
'img/3.jpg',
'img/4.jpg',
'img/wxicon.jpg'
];
var loading = document.querySelector('.loading');
var loadingPro = loading.querySelector('.top');
var imgArrLength = imgArr.length;
var imageKey = 0;
imgArr.forEach(function (val,key) {
var oImg = new Image();
oImg.onload = function(){
oImg.onload = null;
loadingPro.style.width = Math.ceil(100*(++imageKey)/imgArrLength)+'%';
if (imageKey == imgArrLength) {
$('.preload-bg').each(function (i,v) {
v.style.backgroundImage = 'url('+v.dataset.preload_src+')';
});
$('.preload-img').each(function (i,v) {
v.src = v.dataset.preload_src;
});
loading.classList.add('none');
pageIndex.classList.remove('none');
// pageReward.classList.remove('none');
// pageMessages.classList.remove('none');
requestAnimationFrame(yunduo);
document.addEventListener("WeixinJSBridgeReady", function () {//微信
bgMusic.play();
}, false);
}
};
oImg.src = val;
});
btnStart.onclick = function () {
btnAudio.play();
pageIndex.classList.add('none');
pageRule.classList.remove('none');
};
btnRule.onclick = function () {
btnAudio.play();
pageRule.classList.add('none');
pageQuestion1.classList.remove('none');
};
//问题一选答案并记录
$('#question1 .answer1').each(function (i,val) {
val.onclick =function () {
btnAudio.play();
$('#question1 .answer1').each(function (i,v) {
v.classList.remove('active');
});
val.classList.add('active');
answer1 = val.dataset.value;
}
});
//问题一点击按钮播放
btnGifPlay.onclick = function () {
btnAudio.play();
var _this = this;
var src = btnGifImg.src;
var dataSrc = btnGifImg.dataset.src;
_this.classList.add('none');
setTimeout(function () {
btnGifImg.src = dataSrc;
},500);
setTimeout(function () {
_this.classList.remove('none');
btnGifImg.src = src;
},9500);
};
btnQuestion1.onclick = function () {
btnAudio.play();
if (answer1) {
pageQuestion1.classList.add('none');
pageQuestion2.classList.remove('none');
}
};
//问题二选和尚
$('.master-small img').each(function (key,val) {
val.onclick =function () {
btnAudio.play();
$('.bingqi img').each(function (i,v) {
v.classList.remove('active');
});
if (answer2['as'+(key+1)]) {
pageQuestion2.querySelectorAll('.bingqi img')[answer2['as'+(key+1)]-1].classList.add('active');
}
$('.master-small img').each(function (i,v) {
v.classList.remove('active');
});
val.classList.add('active');
$('.master-big').each(function (i,v) {
v.classList.add('none');
});
pageQuestion2.querySelectorAll('.master-big')[key].classList.remove('none');
currentMaster = key+1;
}
});
//问题二选兵器
$('.bingqi img').each(function (key,val) {
val.onclick = function () {
btnAudio.play();
pageQuestion2.querySelectorAll('.bingqi img').forEach(function (v) {
v.classList.remove('active');
});
val.classList.add('active');
answer2['as'+currentMaster] = key+1;
}
});
btnQuestion2.onclick = function () {
btnAudio.play();
if (answer2.as3 && answer2.as1 && answer2.as2) {
if ((answer2.as1 === 1) && (answer2.as2 === 2) && (answer2.as3 === 4) && (answer1=='c')) {
pageQuestion2.classList.add('none');
pageReward.classList.remove('none');
} else {
pageFail.classList.remove('none');
}
}
else {
alert ('注意！三位大师都要匹配相应兵器哦~');
}
};
//重新开始
btnRestart.onclick = function () {
btnAudio.play();
pageFail.classList.add('none');
pageIndex.classList.remove('none');
//清空之前答案
pageQuestion1.querySelectorAll('.answer1').forEach(function (v) {
v.classList.remove('active');
});
answer1 = '';
pageQuestion2.querySelectorAll('.master-small img').forEach(function (v) {
v.classList.remove('active');
});
pageQuestion2.querySelectorAll('.master-small img')[0].classList.add('active');
pageQuestion2.querySelectorAll('.bingqi img').forEach(function (v) {
v.classList.remove('active');
});
answer2 = {};
currentMaster = 1;
};
//抽奖
var is_click = 1;
btnZhizhen.onclick = function () {
btnAudio.play();
if (!is_click) {
return false;
}
var _this = this;
var zhongjiang = 1;
is_click = 0;
//请求抽奖结果决定停止位置
$.ajax({
type: 'post',
url: 'https://wx.ouu.me/home/getHomeLuckdraw',
data: {
openid: open_id
},
dataType: 'json',
success: function(data){
reward = data.date.yes || '5';
if (reward == '1') {
_this.classList.add('yideng');
jiangpinImg.src = 'img/1.jpg';
jiangpinName.innerHTML = '昂坪360 精美行李带<span>（价值HK$120）</span>';
} else if(reward == '2') {
var erdeng = (Math.random()>0.5)? 'erdeng1':'erdeng2';
_this.classList.add(erdeng);
jiangpinImg.src = 'img/2.png';
jiangpinName.innerHTML = '昂坪360 化妆品收纳袋<span>（价值HK$120）</span>';
} else if(reward == '3') {
var sandeng = (Math.random()>0.5)? 'sandeng1':'sandeng2';
_this.classList.add(sandeng);
jiangpinImg.src = 'img/3.jpg';
jiangpinName.innerHTML = '昂坪360 缆车小钱包<span>（价值HK$130）</span>';
} else if(reward == '4') {
var youxiu = (Math.random()>0.5)? 'youxiu1':'youxiu2';
_this.classList.add(youxiu);
jiangpinImg.src = 'img/4.jpg';
jiangpinName.innerHTML = '驴妈妈 小驴公仔';
} else {
var xiexie = (Math.random()>0.5)? 'xiexie1':'xiexie2';
_this.classList.add(xiexie);
zhongjiang = 0
}
setTimeout(function () {
if (zhongjiang) {
pageReward.classList.add('none');
pageMessages.classList.remove('none');
} else {
pageAgain.classList.remove('none');
}
},5200)
}
});
};
//再来一次
btnAgain.onclick = function () {
btnAudio.play();
btnZhizhen.className = 'zhizhen';
is_click
|
yun1Left = 0;
}
req
|
conditional_block
|
images.py
|
)
# timestamp of when image was added
# images:ids:timestamps = sorted (ids,timestamp)
# all the image ids for the page
# images:page_ids:<page_url> (ids)
# last time an image was added from page
# images:pages:timestamps = sorted (url,timestamp)
# images meta data
# images:id = {}
def _image_to_dict(self, image):
data = {}
ignored_attrs = ['data']
for attrs in image.thrift_spec[1:]:
attr = attrs[2]
if attr in ignored_attrs:
continue
v = getattr(image,attr)
if v is not None:
data[attr] = v
return data
def _dict_to_image(self, data):
image = o.Image()
for attrs in image.thrift_spec[1:]:
attr = attrs[2]
v = data.get(attr)
if v is not None:
# we might need to update the value
# type, since all values come back
# from redis as strings
attr_type = attrs[1]
# float
if attr_type == 4:
setattr(image,attr,float(v))
# int
elif attr_type == 8:
setattr(image,attr,int(v))
else:
setattr(image,attr,v)
return image
def _delete_from_redis(self, image):
# make these a transaction
pipe = self.rc.pipeline()
# remove it from the id set
pipe.zrem('images:ids:timestamps',image.id)
# remove it's hash
pipe.delete('images:%s' % image.id)
# decriment the count for it's image data
pipe.srem('images:datainstances:%s' % image.shahash,
image.id)
# remove image from the page's id set
if image.source_page_url:
pipe.zrem('images:page_ids:%s' % image.source_page_url,
image.id)
# make it happen
pipe.execute()
return True
def _save_to_redis(self, image):
# make these a transaction
pipe = self.rc.pipeline()
# if our image doesn't have an id, set it up w/ one
if not image.id:
print 'got new image: %s' % image.shahash
image.id = self.rc.incr('images:next_id')
pipe.sadd('images:datainstances:%s' % image.shahash,
image.id)
# check and see if we used to have a different shahash
old_shahash = self.rc.hget('images:%s' % image.id,'shahash')
if old_shahash != image.shahash:
# remove our id from the old shahash tracker
pipe.srem('images:datainstances:%s' % old_shahash,
image.id)
# add it to the new tracker
pipe.sadd('images:datainstances:%s' % image.shahash,
image.id)
# update / set our timestamp
da = 0.0
if image.downloaded_at:
da = image.downloaded_at
else:
da = time.time()
pipe.zadd('images:ids:timestamps',image.id, da)
# add this image to the page's id set
if image.source_page_url:
pipe.zadd('images:page_ids:%s' % image.source_page_url,
image.id, da)
# update our last scrape time for the page
pipe.zadd('images:pages:timestamps',
image.source_page_url, image.id)
# take our image and make a dict
image_data = self._image_to_dict(image)
# set our data to redis
key = 'images:%s' % image.id
pipe.hmset(key,image_data)
# execute our pipe
pipe.execute()
return image
def _get_from_redis(self, image_id):
# if the image id is in the id set than pull it's details
if self.rc.zrank('images:ids:timestamps',image_id) is not None:
# get the image data from redis
key = 'images:%s' % image_id
image_data = self.rc.hgetall(key)
if not image_data:
print 'redis had no image data'
return None
image = self._dict_to_image(image_data)
return image
return None
def _populate_image_data(self, image):
if not image.shahash:
return None
with connect(Blobby) as c:
image.data = c.get_data(image.shahash)
return image
def _set_image_data(self, image):
if image.data is not None:
|
return image
def get_image(self, image_id):
""" returns Image for given id or blank Image """
# see if we have an image
image = self._get_from_redis(image_id)
if not image:
raise o.ImageNotFound('Could not get image', image_id)
# pull the actual image data
self._populate_image_data(image)
return image
def add_image(self, image):
""" like set but if we already have this image from this
page we're not going to add it again. will also
fill out image stats (size, dimension) """
# we're only for new images, no i'ds allowed
# if u want to set an id by hand use set_image
if image.id:
raise o.Exception('Can not add image with id')
if not image.data:
raise o.Exception('Image must have data')
if not image.source_page_url:
raise o.Exception('Image must have source page url')
# update it's stats
image = self.populate_image_stats(image)
# only add the image if we haven't seen it beforeQ
# if we've seen it before there will be an id which
# the set of images w/ this data and from this page share
ids = self.rc.sinter('images:datainstance:%s' % image.shahash,
'images:page_ids:%s' % image.source_page_url)
# we don't need to continue
# we'll return back their original msg, w/o the id set
if ids:
print 'image already exists [%s], not setting' % ids
return image
# so the image appears to be new, good for it
return self.set_image(image)
def set_image(self, image):
""" sets image data, returns image """
# would be better if we only saved if it didn't exist
if image.data:
# save the images data
self._set_image_data(image)
# could be an update, could be new
image = self._save_to_redis(image)
# let the world know we have added a new image
self.revent.fire('image_added',{
'source_page_url': image.source_page_url,
'source_url': image.source_url,
'shahash': image.shahash,
'vhash': image.vhash,
'xdim': image.xdim,
'ydim': image.ydim,
})
return image
def delete_image(self, image_id):
""" removes an image """
# get it's image obj
try:
image = self.get_image(image_id)
except o.ImageNotFound, ex:
return False
# delete the redis data
self._delete_from_redis(image)
# see if we need to remove the image data
if self.rc.scard('images:datainstances:%s' % image.shahash) == 0:
# no more images w/ the same data, remove image data
with connect(Blobby) as c:
c.delete_data(image.shahash)
# it's gone, let'm know
self.revent.fire('image_deleted',{
'source_page_url': image.source_page_url,
'source_url': image.source_url,
'shahash': image.shahash,
'vhash': image.vhash,
'xdim': image.xdim,
'ydim': image.ydim,
})
# and we're done!
return True
def get_images_since(self, image_id=None, timestamp=None,
offset=10, limit=0):
""" returns list of tublr images or blank list which were
added after given image id or timestamp """
print '%s %s %s %s' % (image_id,timestamp,limit,offset)
if image_id is not None:
print 'got image id'
# figure out what the current id is and than grab
# our sorted set by index assuming that all ids
# contain an image
next_id = int(self.rc.get('images:next_id') or 0)
# how far from the end is the id given
d = next_id - image_id
start = next_id - d
end = next_id - d + limit - 1
print 'getting between %s %s' % (start,end)
# starting back where we think this image is to + limit
ids = self.rc.zrange('images:ids:timestamps',start,end)
print 'got ids: %
|
with connect(Blobby) as c:
image.shahash = c.set_data(image.data)
|
conditional_block
|
images.py
|
ids:timestamps',image.id)
# remove it's hash
pipe.delete('images:%s' % image.id)
# decriment the count for it's image data
pipe.srem('images:datainstances:%s' % image.shahash,
image.id)
# remove image from the page's id set
if image.source_page_url:
pipe.zrem('images:page_ids:%s' % image.source_page_url,
image.id)
# make it happen
pipe.execute()
return True
def _save_to_redis(self, image):
# make these a transaction
pipe = self.rc.pipeline()
# if our image doesn't have an id, set it up w/ one
if not image.id:
print 'got new image: %s' % image.shahash
image.id = self.rc.incr('images:next_id')
pipe.sadd('images:datainstances:%s' % image.shahash,
image.id)
# check and see if we used to have a different shahash
old_shahash = self.rc.hget('images:%s' % image.id,'shahash')
if old_shahash != image.shahash:
# remove our id from the old shahash tracker
pipe.srem('images:datainstances:%s' % old_shahash,
image.id)
# add it to the new tracker
pipe.sadd('images:datainstances:%s' % image.shahash,
image.id)
# update / set our timestamp
da = 0.0
if image.downloaded_at:
da = image.downloaded_at
else:
da = time.time()
pipe.zadd('images:ids:timestamps',image.id, da)
# add this image to the page's id set
if image.source_page_url:
pipe.zadd('images:page_ids:%s' % image.source_page_url,
image.id, da)
# update our last scrape time for the page
pipe.zadd('images:pages:timestamps',
image.source_page_url, image.id)
# take our image and make a dict
image_data = self._image_to_dict(image)
# set our data to redis
key = 'images:%s' % image.id
pipe.hmset(key,image_data)
# execute our pipe
pipe.execute()
return image
def _get_from_redis(self, image_id):
# if the image id is in the id set than pull it's details
if self.rc.zrank('images:ids:timestamps',image_id) is not None:
# get the image data from redis
key = 'images:%s' % image_id
image_data = self.rc.hgetall(key)
if not image_data:
print 'redis had no image data'
return None
image = self._dict_to_image(image_data)
return image
return None
def _populate_image_data(self, image):
if not image.shahash:
return None
with connect(Blobby) as c:
image.data = c.get_data(image.shahash)
return image
def _set_image_data(self, image):
if image.data is not None:
with connect(Blobby) as c:
image.shahash = c.set_data(image.data)
return image
def get_image(self, image_id):
""" returns Image for given id or blank Image """
# see if we have an image
image = self._get_from_redis(image_id)
if not image:
raise o.ImageNotFound('Could not get image', image_id)
# pull the actual image data
self._populate_image_data(image)
return image
def add_image(self, image):
""" like set but if we already have this image from this
page we're not going to add it again. will also
fill out image stats (size, dimension) """
# we're only for new images, no i'ds allowed
# if u want to set an id by hand use set_image
if image.id:
raise o.Exception('Can not add image with id')
if not image.data:
raise o.Exception('Image must have data')
if not image.source_page_url:
raise o.Exception('Image must have source page url')
# update it's stats
image = self.populate_image_stats(image)
# only add the image if we haven't seen it beforeQ
# if we've seen it before there will be an id which
# the set of images w/ this data and from this page share
ids = self.rc.sinter('images:datainstance:%s' % image.shahash,
'images:page_ids:%s' % image.source_page_url)
# we don't need to continue
# we'll return back their original msg, w/o the id set
if ids:
print 'image already exists [%s], not setting' % ids
return image
# so the image appears to be new, good for it
return self.set_image(image)
def set_image(self, image):
""" sets image data, returns image """
# would be better if we only saved if it didn't exist
if image.data:
# save the images data
self._set_image_data(image)
# could be an update, could be new
image = self._save_to_redis(image)
# let the world know we have added a new image
self.revent.fire('image_added',{
'source_page_url': image.source_page_url,
'source_url': image.source_url,
'shahash': image.shahash,
'vhash': image.vhash,
'xdim': image.xdim,
'ydim': image.ydim,
})
return image
def delete_image(self, image_id):
""" removes an image """
# get it's image obj
try:
image = self.get_image(image_id)
except o.ImageNotFound, ex:
return False
# delete the redis data
self._delete_from_redis(image)
# see if we need to remove the image data
if self.rc.scard('images:datainstances:%s' % image.shahash) == 0:
# no more images w/ the same data, remove image data
with connect(Blobby) as c:
c.delete_data(image.shahash)
# it's gone, let'm know
self.revent.fire('image_deleted',{
'source_page_url': image.source_page_url,
'source_url': image.source_url,
'shahash': image.shahash,
'vhash': image.vhash,
'xdim': image.xdim,
'ydim': image.ydim,
})
# and we're done!
return True
def get_images_since(self, image_id=None, timestamp=None,
offset=10, limit=0):
""" returns list of tublr images or blank list which were
added after given image id or timestamp """
print '%s %s %s %s' % (image_id,timestamp,limit,offset)
if image_id is not None:
print 'got image id'
# figure out what the current id is and than grab
# our sorted set by index assuming that all ids
# contain an image
next_id = int(self.rc.get('images:next_id') or 0)
# how far from the end is the id given
d = next_id - image_id
start = next_id - d
end = next_id - d + limit - 1
print 'getting between %s %s' % (start,end)
# starting back where we think this image is to + limit
ids = self.rc.zrange('images:ids:timestamps',start,end)
print 'got ids: %s' % ids
elif timestamp:
print 'from timestamp: %s' % timestamp
# get ids from our sorted set by it's weight (aka timestamp)
# TODO: not use inf
ids = self.rc.zrangebyscore('images:ids:timestamps',
timestamp,'+inf')
else:
print 'could not find images'
ids = []
# page ids
if offset < len(ids):
ids = ids[offset:max(len(ids),limit)]
else:
ids = []
print 'found ids: %s' % ids
# return images for each ID
images = map(self._get_from_redis,ids)
# populate image data
map(self._populate_image_data,images)
return images
def search(self, source_blog_url=None, since_timestamp=None,
before_timestamp=None, ids=[], source_url=None):
""" returns list of images, searches passed on passed params """
pass
def populate_image_stats(self, image):
""" returns a Image w/ image data + stats filled
out """
ti = image
image_data = ti.data
if not ti.data:
return ti
ti.size = len(image_data)
try:
with connect(Blobby) as c:
ti.shahash = c.get_data_bhash(image_data)
except o.Exception, ex:
|
raise o.Exception('oException getting shahash: %s' % ex.msg)
except Exception, ex:
raise o.Exception('Exception getting shahash: %s' % ex)
|
random_line_split
|
|
images.py
|
)
# timestamp of when image was added
# images:ids:timestamps = sorted (ids,timestamp)
# all the image ids for the page
# images:page_ids:<page_url> (ids)
# last time an image was added from page
# images:pages:timestamps = sorted (url,timestamp)
# images meta data
# images:id = {}
def _image_to_dict(self, image):
data = {}
ignored_attrs = ['data']
for attrs in image.thrift_spec[1:]:
attr = attrs[2]
if attr in ignored_attrs:
continue
v = getattr(image,attr)
if v is not None:
data[attr] = v
return data
def _dict_to_image(self, data):
image = o.Image()
for attrs in image.thrift_spec[1:]:
attr = attrs[2]
v = data.get(attr)
if v is not None:
# we might need to update the value
# type, since all values come back
# from redis as strings
attr_type = attrs[1]
# float
if attr_type == 4:
setattr(image,attr,float(v))
# int
elif attr_type == 8:
setattr(image,attr,int(v))
else:
setattr(image,attr,v)
return image
def _delete_from_redis(self, image):
# make these a transaction
pipe = self.rc.pipeline()
# remove it from the id set
pipe.zrem('images:ids:timestamps',image.id)
# remove it's hash
pipe.delete('images:%s' % image.id)
# decriment the count for it's image data
pipe.srem('images:datainstances:%s' % image.shahash,
image.id)
# remove image from the page's id set
if image.source_page_url:
pipe.zrem('images:page_ids:%s' % image.source_page_url,
image.id)
# make it happen
pipe.execute()
return True
def _save_to_redis(self, image):
# make these a transaction
|
# update / set our timestamp
da = 0.0
if image.downloaded_at:
da = image.downloaded_at
else:
da = time.time()
pipe.zadd('images:ids:timestamps',image.id, da)
# add this image to the page's id set
if image.source_page_url:
pipe.zadd('images:page_ids:%s' % image.source_page_url,
image.id, da)
# update our last scrape time for the page
pipe.zadd('images:pages:timestamps',
image.source_page_url, image.id)
# take our image and make a dict
image_data = self._image_to_dict(image)
# set our data to redis
key = 'images:%s' % image.id
pipe.hmset(key,image_data)
# execute our pipe
pipe.execute()
return image
def _get_from_redis(self, image_id):
# if the image id is in the id set than pull it's details
if self.rc.zrank('images:ids:timestamps',image_id) is not None:
# get the image data from redis
key = 'images:%s' % image_id
image_data = self.rc.hgetall(key)
if not image_data:
print 'redis had no image data'
return None
image = self._dict_to_image(image_data)
return image
return None
def _populate_image_data(self, image):
if not image.shahash:
return None
with connect(Blobby) as c:
image.data = c.get_data(image.shahash)
return image
def _set_image_data(self, image):
if image.data is not None:
with connect(Blobby) as c:
image.shahash = c.set_data(image.data)
return image
def get_image(self, image_id):
""" returns Image for given id or blank Image """
# see if we have an image
image = self._get_from_redis(image_id)
if not image:
raise o.ImageNotFound('Could not get image', image_id)
# pull the actual image data
self._populate_image_data(image)
return image
def add_image(self, image):
""" like set but if we already have this image from this
page we're not going to add it again. will also
fill out image stats (size, dimension) """
# we're only for new images, no i'ds allowed
# if u want to set an id by hand use set_image
if image.id:
raise o.Exception('Can not add image with id')
if not image.data:
raise o.Exception('Image must have data')
if not image.source_page_url:
raise o.Exception('Image must have source page url')
# update it's stats
image = self.populate_image_stats(image)
# only add the image if we haven't seen it beforeQ
# if we've seen it before there will be an id which
# the set of images w/ this data and from this page share
ids = self.rc.sinter('images:datainstance:%s' % image.shahash,
'images:page_ids:%s' % image.source_page_url)
# we don't need to continue
# we'll return back their original msg, w/o the id set
if ids:
print 'image already exists [%s], not setting' % ids
return image
# so the image appears to be new, good for it
return self.set_image(image)
def set_image(self, image):
""" sets image data, returns image """
# would be better if we only saved if it didn't exist
if image.data:
# save the images data
self._set_image_data(image)
# could be an update, could be new
image = self._save_to_redis(image)
# let the world know we have added a new image
self.revent.fire('image_added',{
'source_page_url': image.source_page_url,
'source_url': image.source_url,
'shahash': image.shahash,
'vhash': image.vhash,
'xdim': image.xdim,
'ydim': image.ydim,
})
return image
def delete_image(self, image_id):
""" removes an image """
# get it's image obj
try:
image = self.get_image(image_id)
except o.ImageNotFound, ex:
return False
# delete the redis data
self._delete_from_redis(image)
# see if we need to remove the image data
if self.rc.scard('images:datainstances:%s' % image.shahash) == 0:
# no more images w/ the same data, remove image data
with connect(Blobby) as c:
c.delete_data(image.shahash)
# it's gone, let'm know
self.revent.fire('image_deleted',{
'source_page_url': image.source_page_url,
'source_url': image.source_url,
'shahash': image.shahash,
'vhash': image.vhash,
'xdim': image.xdim,
'ydim': image.ydim,
})
# and we're done!
return True
def get_images_since(self, image_id=None, timestamp=None,
offset=10, limit=0):
""" returns list of tublr images or blank list which were
added after given image id or timestamp """
print '%s %s %s %s' % (image_id,timestamp,limit,offset)
if image_id is not None:
print 'got image id'
# figure out what the current id is and than grab
# our sorted set by index assuming that all ids
# contain an image
next_id = int(self.rc.get('images:next_id') or 0)
# how far from the end is the id given
d = next_id - image_id
start = next_id - d
end = next_id - d + limit - 1
print 'getting between %s %s' % (start,end)
# starting back where we think this image is to + limit
ids = self.rc.zrange('images:ids:timestamps',start,end)
print 'got ids: %s
|
pipe = self.rc.pipeline()
# if our image doesn't have an id, set it up w/ one
if not image.id:
print 'got new image: %s' % image.shahash
image.id = self.rc.incr('images:next_id')
pipe.sadd('images:datainstances:%s' % image.shahash,
image.id)
# check and see if we used to have a different shahash
old_shahash = self.rc.hget('images:%s' % image.id,'shahash')
if old_shahash != image.shahash:
# remove our id from the old shahash tracker
pipe.srem('images:datainstances:%s' % old_shahash,
image.id)
# add it to the new tracker
pipe.sadd('images:datainstances:%s' % image.shahash,
image.id)
|
identifier_body
|
images.py
|
(object):
def __init__(self, redis_host='127.0.0.1'):
self.redis_host = redis_host
self.rc = Redis(redis_host)
self.revent = ReventClient(redis_host=self.redis_host)
# redis keys
# incr this for the next image id
# images:next_id = next_id
# all the images for the given sha
# images:datainstances:<shahash> = (ids)
# timestamp of when image was added
# images:ids:timestamps = sorted (ids,timestamp)
# all the image ids for the page
# images:page_ids:<page_url> (ids)
# last time an image was added from page
# images:pages:timestamps = sorted (url,timestamp)
# images meta data
# images:id = {}
def _image_to_dict(self, image):
data = {}
ignored_attrs = ['data']
for attrs in image.thrift_spec[1:]:
attr = attrs[2]
if attr in ignored_attrs:
continue
v = getattr(image,attr)
if v is not None:
data[attr] = v
return data
def _dict_to_image(self, data):
image = o.Image()
for attrs in image.thrift_spec[1:]:
attr = attrs[2]
v = data.get(attr)
if v is not None:
# we might need to update the value
# type, since all values come back
# from redis as strings
attr_type = attrs[1]
# float
if attr_type == 4:
setattr(image,attr,float(v))
# int
elif attr_type == 8:
setattr(image,attr,int(v))
else:
setattr(image,attr,v)
return image
def _delete_from_redis(self, image):
# make these a transaction
pipe = self.rc.pipeline()
# remove it from the id set
pipe.zrem('images:ids:timestamps',image.id)
# remove it's hash
pipe.delete('images:%s' % image.id)
# decriment the count for it's image data
pipe.srem('images:datainstances:%s' % image.shahash,
image.id)
# remove image from the page's id set
if image.source_page_url:
pipe.zrem('images:page_ids:%s' % image.source_page_url,
image.id)
# make it happen
pipe.execute()
return True
def _save_to_redis(self, image):
# make these a transaction
pipe = self.rc.pipeline()
# if our image doesn't have an id, set it up w/ one
if not image.id:
print 'got new image: %s' % image.shahash
image.id = self.rc.incr('images:next_id')
pipe.sadd('images:datainstances:%s' % image.shahash,
image.id)
# check and see if we used to have a different shahash
old_shahash = self.rc.hget('images:%s' % image.id,'shahash')
if old_shahash != image.shahash:
# remove our id from the old shahash tracker
pipe.srem('images:datainstances:%s' % old_shahash,
image.id)
# add it to the new tracker
pipe.sadd('images:datainstances:%s' % image.shahash,
image.id)
# update / set our timestamp
da = 0.0
if image.downloaded_at:
da = image.downloaded_at
else:
da = time.time()
pipe.zadd('images:ids:timestamps',image.id, da)
# add this image to the page's id set
if image.source_page_url:
pipe.zadd('images:page_ids:%s' % image.source_page_url,
image.id, da)
# update our last scrape time for the page
pipe.zadd('images:pages:timestamps',
image.source_page_url, image.id)
# take our image and make a dict
image_data = self._image_to_dict(image)
# set our data to redis
key = 'images:%s' % image.id
pipe.hmset(key,image_data)
# execute our pipe
pipe.execute()
return image
def _get_from_redis(self, image_id):
# if the image id is in the id set than pull it's details
if self.rc.zrank('images:ids:timestamps',image_id) is not None:
# get the image data from redis
key = 'images:%s' % image_id
image_data = self.rc.hgetall(key)
if not image_data:
print 'redis had no image data'
return None
image = self._dict_to_image(image_data)
return image
return None
def _populate_image_data(self, image):
if not image.shahash:
return None
with connect(Blobby) as c:
image.data = c.get_data(image.shahash)
return image
def _set_image_data(self, image):
if image.data is not None:
with connect(Blobby) as c:
image.shahash = c.set_data(image.data)
return image
def get_image(self, image_id):
""" returns Image for given id or blank Image """
# see if we have an image
image = self._get_from_redis(image_id)
if not image:
raise o.ImageNotFound('Could not get image', image_id)
# pull the actual image data
self._populate_image_data(image)
return image
def add_image(self, image):
""" like set but if we already have this image from this
page we're not going to add it again. will also
fill out image stats (size, dimension) """
# we're only for new images, no i'ds allowed
# if u want to set an id by hand use set_image
if image.id:
raise o.Exception('Can not add image with id')
if not image.data:
raise o.Exception('Image must have data')
if not image.source_page_url:
raise o.Exception('Image must have source page url')
# update it's stats
image = self.populate_image_stats(image)
# only add the image if we haven't seen it beforeQ
# if we've seen it before there will be an id which
# the set of images w/ this data and from this page share
ids = self.rc.sinter('images:datainstance:%s' % image.shahash,
'images:page_ids:%s' % image.source_page_url)
# we don't need to continue
# we'll return back their original msg, w/o the id set
if ids:
print 'image already exists [%s], not setting' % ids
return image
# so the image appears to be new, good for it
return self.set_image(image)
def set_image(self, image):
""" sets image data, returns image """
# would be better if we only saved if it didn't exist
if image.data:
# save the images data
self._set_image_data(image)
# could be an update, could be new
image = self._save_to_redis(image)
# let the world know we have added a new image
self.revent.fire('image_added',{
'source_page_url': image.source_page_url,
'source_url': image.source_url,
'shahash': image.shahash,
'vhash': image.vhash,
'xdim': image.xdim,
'ydim': image.ydim,
})
return image
def delete_image(self, image_id):
""" removes an image """
# get it's image obj
try:
image = self.get_image(image_id)
except o.ImageNotFound, ex:
return False
# delete the redis data
self._delete_from_redis(image)
# see if we need to remove the image data
if self.rc.scard('images:datainstances:%s' % image.shahash) == 0:
# no more images w/ the same data, remove image data
with connect(Blobby) as c:
c.delete_data(image.shahash)
# it's gone, let'm know
self.revent.fire('image_deleted',{
'source_page_url': image.source_page_url,
'source_url': image.source_url,
'shahash': image.shahash,
'vhash': image.vhash,
'xdim': image.xdim,
'ydim': image.ydim,
})
# and we're done!
return True
def get_images_since(self, image_id=None, timestamp=None,
offset=10, limit=0):
""" returns list of tublr images or blank list which were
added after given image id or timestamp """
print '%s %s %s %s' % (image_id,timestamp,limit,offset)
if image_id is not None:
print 'got image id'
# figure out what the current id is and than grab
# our sorted set by index assuming that all ids
# contain an image
next_id = int(self.rc.get('images:next
|
ImagesHandler
|
identifier_name
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.